Source confidence: medium

World Labs — Marble and the Era of Generative 3D Worlds

In short: Run a structured evaluation of World Labs' Marble (Fei-Fei Li's Large World Model product, closed-source, browser-based) for one concrete job: game-level and previs blockout.

Key fact Detail
What it covers 3D, creative coding, image generation
Tools World Labs
Posts covered 1 post (1 S-tier) · top: World Labs — explorable 3D worlds from a…
Creators @rpn
Sources dated Dec 2024
Prompt system Run-it-yourself prompts
Last verified 2026-10-22

Company: World Labs (https://www.worldlabs.ai) Founders: Fei-Fei Li (Stanford, ImageNet, "AI godmother"), Justin Johnson, Ben Mildenhall (co-inventor of NeRF), Christoph Lassner Product: Marble — a commercial 3D world generation model (launched Nov 2025) Status: Closed-source commercial product. Web app in beta, no open weights, no public API at launch. Access is via waitlist → browser UI. Repo: None — not open source. Nothing to clone.

What it is

World Labs is Fei-Fei Li's "spatial intelligence" startup. Their thesis, stated plainly by Li, is that the next leap in AI is not bigger language models but systems that understand and generate 3D space — because physical reality, robotics, AR/VR, creative tools, and scientific simulation all live in 3D, not in flat text or 2D pixels. She calls the category Large World Models (LWMs), positioned as the 3D-native cousin of LLMs.

Marble, launched in November 2025, is their first commercial product and the first public instance of an LWM you can actually poke. Feed it a text description, one or more images, a video clip, or a rough blocky 3D layout, and it generates a complete, explorable, persistent 3D environment — a room, a landscape, a whole stylized scene. You can then fly a camera through it, edit it with AI-native tools, or export it as Gaussian splats, meshes, or rendered video.

This is fundamentally a different product from Hunyuan3D-2 or Tripo (see guides/hunyuan3d-2.md and guides/blender-mcp-tripo-pipeline.md). Those tools generate single objects — a chair, a character, a prop. Marble generates environments — the whole tea room, including the walls, the lighting, the objects, and the geometric relationships between them. It's a generator at the scale of Unreal Engine levels, not individual assets.

How it works (what we can infer)

World Labs has not published full technical papers, but they've been surprisingly open about the high-level architecture in interviews and case studies. The approach is a hybrid that borrows from several active research threads:

1. 3D Gaussian Splatting for appearance. Marble represents the visual content of a scene as a dense cloud of 3D Gaussians — each an anisotropic blob with position, scale, orientation, color, and opacity. This is the same technique that replaced NeRFs as the leading photorealistic 3D representation in 2023–2024, pioneered partly by co-founder Ben Mildenhall's lab work. Gaussians are cheap to render (real-time rasterization, not volumetric ray marching) and give extremely high fidelity for static scenes.

2. "Collider mesh" for geometry. Alongside the Gaussians, Marble generates a low-poly triangle mesh that defines the physical boundaries of the space. This is the bit that makes the scene usable, not just lookable — the mesh is what a camera collides with, what an avatar walks on, what a physics engine simulates against. It also anchors the Gaussians so they don't drift or blur when edited.

3. Discrete spatial state, not frame prediction. This is the key claim that separates Marble from video-model competitors like Sora, Veo, and Runway. Those models predict "what pixel comes next" — you move the camera, they roll the generative dice, and the world changes subtly each time you look away. Marble generates one scene up front and keeps it fixed: move the camera away from a chair and back, the chair is in exactly the same place, with exactly the same lighting on exactly the same surface. This is table stakes for a usable creative tool and impossible for a pure video model without explicit memory.

4. Multi-modal conditioning. Text prompts, images, videos, and coarse 3D layouts can all condition the generation. The 3D layout path is the interesting one — you sketch a blocky arrangement ("couch here, table here, window there") and Marble fills in the visual details while respecting your structure. World Labs calls this a hybrid 3D editor: block out the geometry you care about, let the model hallucinate the rest.

The underlying generative model is almost certainly a diffusion transformer operating on a 3D latent representation (probably a voxel or triplane latent) that decodes to the Gaussian + mesh pair. They haven't confirmed the architecture publicly. Training data is rumored to be a mix of photogrammetric scans, synthetic UE5/Unity scenes, and multiview image collections — standard LWM training fare.

How it compares to the rest of the world-generation landscape

This is a crowded research area as of 2026. Here's where Marble sits:

vs. Google DeepMind Genie 3 (2025): Genie 3 is an interactive world model — you press keys and it generates the next frame like a video game being dreamt in real time. Impressive, but it suffers from the exact problem Marble avoids: it has limited persistence, the world drifts, and you can't export anything. Genie is a research demo of interactive video; Marble is a product that outputs files.

vs. NVIDIA GET3D / Magic3D / Scenescape (2023): Earlier generations of scene generators. Scenescape in particular pioneered "generate a mesh you can fly through from a single image" but at much lower quality and with visible tiling artifacts. Marble is a clean generational leap.

vs. Luma Dream Machine + Genie-style approaches: Luma focuses on video and NeRF-from-video capture, not outright world generation. Different problem.

vs. Hunyuan3D-2 / Tripo (single-object generators): Completely different scope. Hunyuan3D-2 makes a chair. Marble makes the room the chair is in. You'd use them together — Marble for the environment, Hunyuan3D-2/Tripo for hero assets you want more control over.

vs. Meta's "world models" work (Yann LeCun's V-JEPA line): Meta is pursuing world models as prediction systems for robotics and planning — not renderable, not creative tools. Different audience entirely.

vs. Wayve / 1X / Tesla world models: These are driving / robotics world models, tuned for dynamics prediction, not aesthetic scene generation. Adjacent but separate category.

Marble is, as of early 2026, the only product that combines generation quality, persistence, editing, and standard export formats. That's why it matters.

System requirements

None. Marble runs entirely in World Labs' cloud. You use it through a web app in a modern browser. No GPU required, no install, no setup. That's the upside of a closed commercial product.

The downsides:

Quick start

There's nothing to install. The workflow is:

  1. Sign up at https://www.worldlabs.ai and join the waitlist (or use an invite)
  2. Log into the Marble web app
  3. Pick an input modality:
    • Text: "a cyberpunk alleyway at night, neon signs, wet pavement, dense fog"
    • Image: upload a reference photo
    • Video: upload a short clip
    • 3D layout: block out geometry with their web editor
  4. Wait ~1–3 minutes for generation
  5. Explore the world with their web viewer (WASD + mouse look)
  6. Edit — move objects, change lighting, relight, paint over regions
  7. Export:
    • Gaussian splats (.ply with Gaussian attributes, or their own format) — for real-time viewers like Luma, Polycam, or Three.js splat renderers
    • Mesh (GLB) — for Blender, Unity, Unreal, three.js
    • Video — rendered flythrough, for sharing and traditional post

Expect the export quality to be "good enough for previs and production dailies" rather than "final pixel ready for film." You will re-touch in Blender or Unreal.

What we could build with it

The question with Marble isn't "what's possible" — it's "what becomes cheap enough to do casually that it changes the creative workflow." Some ideas:

Implications for creative tools

Marble (and the LWM category more generally) is where generative AI and 3D tools are heading over the next two years. The relevant trends to watch:

  1. Persistence is the defining feature. Video models will add memory; world models will add interactivity. They'll meet in the middle. Whoever solves "persistent, editable, exportable" first wins the creative-tools market.
  2. Gaussian splats are becoming the interchange format the way GLB became for meshes. Expect Blender, Unreal, Unity, and three.js to all ship first-class splat support by end of 2026 (some already have it via plugins).
  3. Open-weight competitors are coming. Tencent (Hunyuan), Alibaba, Meta, and Stability all have research lines aimed at open LWMs. Marble's closed-weight moat is at most 12–18 months wide. Worth tracking Hunyuan especially given Tencent's track record of open-sourcing their research (HY-Motion, Hunyuan3D-2, Hunyuan Video).
  4. The single-object tools (Tripo, Hunyuan3D-2) and the world tools (Marble) will integrate. The natural workflow is: generate the room with Marble, generate the hero prop with Hunyuan3D-2 / Tripo, composite in Blender via the MCP pipeline (see guides/blender-mcp-tripo-pipeline.md).

For our purposes: Marble is worth watching closely and testing on the web when you get access, but it is not something to build a production pipeline on yet. The open-weight companions (Hunyuan3D-2, Trellis, Tripo's API) are the tools to actually build with today, and Marble shows where the ceiling is heading.

Sources

Prompt system — run this yourself

Everything below is pasteable into Claude Code, Claude, or any agent. Use the one-shot when you want the whole result in one run; use the step prompts when you want to steer. Every step carries its own audit, and the gap audit at the end makes the agent find and fill what it missed.

Mission. Run a structured evaluation of World Labs' Marble (Fei-Fei Li's Large World Model product, closed-source, browser-based) for one concrete job: game-level and previs blockout. Running this produces a prompt set across text, image, and 3D-layout inputs, exported Gaussian splats and GLB collider meshes, a working import into Blender, three.js, and a game engine with walkable collision, measured persistence and export quality, and a comparison against an open alternative. Done means each guide claim is verified or refuted with files and numbers, and a written verdict on where Marble fits in the pipeline.

1 · Deeper, not bigger

Before running anything, make the task deeper rather than larger. Ask: what would a top professional do here that I am not asking for; what is the rawest material; which methods and tools; what, other than the model or me, proves it right. Then ask for exactly that.

Rewritten prompt — ask for exactly that:

Evaluate World Labs' Marble for game-level and previs blockout, and give me files and numbers rather than impressions.

1. From World Labs' docs and terms, record: input modes, export formats (Gaussian splats as .ply or .spz, GLB mesh, video), credit pricing, whether an API now exists, and the license for commercial use of outputs.
2. Write a brief with acceptance criteria: walkable collider, real-time splat playback at 60 fps on my GPU, assets usable in Blender and a game engine, under 3 minutes per generation.
3. Generate from a fixed prompt set: 10 text, 5 image, 3 blocky 3D layouts. Log time and credits per run.
4. Export splats and GLB for each. Validate GLBs with the Khronos glTF Validator, inspect triangle counts with gltf-transform, check watertightness with trimesh.
5. Import into Blender headless and render fixed poses; play splats in a three.js viewer and measure fps; drop the collider into Godot with a capsule controller and walk a path.
6. Test persistence: same camera pose before and after moving away, SSIM 0.98 or better.
7. Compare against an open alternative on the same brief with two blind reviewers.

Return a claims table, the measurements, the pipeline scripts, and a verdict on where Marble fits.

2 · One-shot prompt

ROLE: You are a technical artist and pipeline TD evaluating a closed commercial 3D generator for a small studio. You judge it by the files it exports and how they behave in real tools, not by its demo reel.

CONTEXT:
- Product: Marble by World Labs (founders Fei-Fei Li, Justin Johnson, Ben Mildenhall, Christoph Lassner). Launched November 2025 as a browser app with waitlist access; closed weights; credit-based pricing.
- Claims to test from the guide: generates persistent explorable environments from text, images, video, or blocky 3D layouts in about 1-3 minutes; represents appearance as 3D Gaussian splats plus a low-poly collider mesh; the scene stays identical when the camera returns, unlike frame-predicting video models (Sora, Veo, Genie 3); exports Gaussian splats (.ply or proprietary), GLB mesh, and rendered video; export quality is good enough for previs, not final pixel; no public API at launch.
- Comparators: Hunyuan3D-2 and Tripo (single objects), Genie 3 (interactive but no export). Tools: Blender 4.x, three.js with a splat renderer such as Spark (sparkjsdev/spark) or similar, Godot 4 or Unity, Khronos glTF Validator, gltf-transform, trimesh, scikit-image SSIM.
- Use case: game-level blockout and film previs.

HARD CONSTRAINTS:
- Fixed prompt set, versioned in prompts.jsonl; no cherry-picking: every generation is logged and scored, including failures.
- Do not upload private or client images; use your own photos or public-domain references.
- Record credits spent per generation and stop at the budget Victor sets.
- Read the terms of service and output license before using any output in a shared project.
- All pipeline steps scripted and headless where possible so results reproduce.

DELIVERABLES, in order:
1. product_facts.md: inputs, exports, formats, pricing, API status, output license, each with a World Labs URL and date checked.
2. brief.md with acceptance criteria: GLB validates with zero errors; collider walkable; splat playback at 60 fps or better on this GPU at 1080p; generation under 3 minutes; usable after Blender import.
3. runs.csv: per prompt, input mode, generation time, credits, export file sizes, splat count, collider triangle count.
4. Validation outputs: gltf-validator reports, gltf-transform inspect output, trimesh watertight and scale checks.
5. pipeline/: Blender headless import and fixed-pose render script; three.js splat viewer page with an fps counter; Godot project with the collider and a capsule controller walking a scripted path.
6. persistence.md: SSIM between renders of the same pose before and after navigating away, in Marble's viewer capture and in the exported splat.
7. compare.md: the same 3 briefs done with an open alternative, judged blind by two reviewers.

GAP ANALYSIS (built in): keep gaps.md. Record anything you could not test (no waitlist access, an export format missing, no layout editor on your plan) and how it limits the verdict. Fill what you can from documentation and community exports; label those as secondhand.

SELF-QUESTIONS before finishing:
- Does the collider mesh align with the splats, or is it offset or scaled?
- What is the real-world scale of exports, and does a 1.8 m capsule fit through doors?
- Do layout-conditioned runs respect my blocked geometry, measured, not eyeballed?
- Is persistence true in the export, or only in the hosted viewer?
- What is the splat count and file size, and does it play at 60 fps here?
- Who owns outputs and can I ship them commercially?
- What happens to my pipeline if World Labs changes pricing or closes access?
- Where does Marble beat the open alternative, and where does it lose?

STOP CONDITIONS: stop and report if there is no access to Marble (deliver the evaluation harness ready to run plus secondhand findings), if the credit budget is reached, or if the terms forbid the intended use.

RETURN FORMAT: markdown report: Verdict (where Marble fits, one paragraph), Product facts, Runs table, Validation, Pipeline results, Persistence, Comparison, Gaps ranked, file paths.

3 · Step-by-step prompts

Step 1 — Ground truth: product, formats, terms

Goal: Know exactly what Marble offers and permits today.

From World Labs' site, Marble docs or help center, blog posts, and terms of service, record in product_facts.md: access model (waitlist, plans), input modes (text, image, multi-image, video, 3D layout editor), generation time claims, edit tools, export formats with extensions (splat .ply, .spz, other; GLB collider or full mesh; video), splat attribute layout, credit pricing per generation and per export, whether a public API or SDK exists now (the guide says none at launch), and the output license for commercial use and what World Labs retains.

Also verify supporting tools: does sparkjsdev/spark exist and render the exported splat format; does nianticlabs/spz document .spz; which Blender add-ons import 3D Gaussian splat .ply. Each row: fact, value, URL, date checked. Mark anything from third-party posts as secondhand.

Expect: product_facts.md with 15+ sourced rows and a tool-compatibility table.

Audit before moving on: Rows without a World Labs or repo URL are unverified. If the license forbids commercial use or requires attribution, flag it at the top. If no access is available, mark generation steps blocked and continue building the harness.

Step 2 — Brief and fixed prompt set

Goal: Define acceptance criteria and comparable inputs before generating.

Write brief.md with acceptance criteria for game blockout and previs: GLB passes Khronos glTF Validator with zero errors; collider walkable by a 0.4 m radius, 1.8 m capsule along a scripted path; splat playback at 60 fps or better at 1080p on this machine's GPU; generation under 3 minutes; scale within 10% of real-world for known objects (a door 2.0-2.1 m); Blender import without manual fixes.

Write prompts.jsonl with 18 entries: 10 text prompts spanning interiors (diner at 3am, tea room), exteriors (cyberpunk alley with wet pavement and fog), and game spaces (three-room dungeon with a corridor); 5 image prompts from your own photos or public-domain images with sources recorded; 3 layout prompts where you block out geometry with known dimensions (a 6 x 4 m room with a 1 m doorway centered on one wall). Each entry: id, mode, input, intended use, measurable expectation.

Expect: brief.md with 6+ numeric criteria; prompts.jsonl with 18 entries including dimensions for layout prompts.

Audit before moving on: Every criterion must be measurable by a tool named in methods. Layout prompts must include dimensions so step 4 can measure adherence. Remove any image you do not have the right to upload.

Step 3 — Generate and export

Goal: Run every prompt once, log everything, export standard files.

Run all 18 prompts in Marble in prompts.jsonl order. For each: start and end timestamps, credits used, any errors, and a screenshot of the hosted viewer at a fixed starting view. Export splats in every offered format, the GLB mesh or collider, and a short rendered flythrough. Save under exports/<id>/ with original filenames preserved.

Record in runs.csv: id, mode, generation seconds, credits, splat file size, splat count (parse the .ply header element vertex count, or the .spz header), GLB size, triangle count (from gltf-transform inspect), and notes. Do not regenerate failures to get a better result; a second attempt is a new row labeled retry. Stop when the credit budget is reached and record which prompts were not run.

Expect: exports/ with 18 folders (or fewer with budget notes), runs.csv complete, viewer screenshots.

Audit before moving on: Check that every runs.csv row has a matching export folder and parsed counts; a missing count means the format was not parsed, so fix the parser. Compute median generation time and compare with the 1-3 minute claim.

Step 4 — Validate and integrate into Blender, three.js, and a game engine

Goal: Prove the exports work in real pipelines.

For each GLB: run the Khronos glTF Validator and save the report; run gltf-transform inspect; load with trimesh to check watertightness, bounds, and units. For layout prompts, measure the room and doorway dimensions on the collider and compare with the blocked-out values.

Blender: write pipeline/blender_import.py that imports the GLB (and splats via a chosen add-on), places a camera at 3 fixed poses, and renders with blender -b -P; log errors.

three.js: build pipeline/viewer.html that loads the splat with Spark or another splat renderer and the GLB, and shows an fps counter; record fps at 1080p for each scene.

Game engine: in Godot 4 (or Unity), import the GLB as a static collider, add a 0.4 m radius, 1.8 m capsule CharacterBody3D, and script it along waypoints through the space; log falls through the floor, stuck frames, and doorway passes. Write integration.md with a table per scene.

Expect: validator reports, inspect outputs, dimension checks, Blender renders, fps table, Godot run logs, integration.md.

Audit before moving on: Fail a scene if the validator reports any error, Blender import errors, fps under 60, or the capsule falls through or gets stuck. Check collider-splat alignment by overlaying the GLB wireframe on a splat render; an offset over 5 cm is a defect to record.

Step 5 — Persistence test and open-alternative comparison

Goal: Test the central persistence claim and benchmark against an alternative.

Persistence: for 5 scenes, capture the hosted viewer at a fixed pose, navigate away for at least 20 seconds through other parts of the scene, return to the exact pose (use any coordinate display or a saved view), and capture again. Repeat for the exported splat in viewer.html with a scripted camera. Compute SSIM with scikit-image on aligned grayscale captures. Also reload the scene in a new session and compare. Write persistence.md.

Comparison: pick 3 briefs. Produce the same scenes with an open alternative: an image-to-3D object generator such as Hunyuan3D-2 for hero props assembled in Blender, or an open scene generator if you can run one. Render matched views. Two reviewers who did not make them choose blindly per brief on usefulness for blockout. Record time spent per approach.

Expect: persistence.md with SSIM per scene and condition; compare.md with matched renders, blind choices, and time per approach.

Audit before moving on: If SSIM is below 0.98 in the hosted viewer, check camera pose alignment before concluding non-persistence. Reviewers must not know which tool made which render; record how blinding was done.

Step 6 — Validate against oracles, gap report, verdict

Goal: Close with evidence and a clear verdict on fit.

Run the oracles and record pass or fail with evidence: (1) Khronos glTF Validator zero errors across exported GLBs; (2) Blender headless import and render succeeds for every scene; (3) Godot capsule walks every scripted path without falls or stuck frames; (4) persistence SSIM 0.98 or higher in hosted viewer and export; (5) splat playback at 60 fps at 1080p; (6) blind reviewers' preferences recorded for 3 briefs.

Write gap_report.md: every guide claim (1-3 minute generation, splats plus collider mesh, persistence versus video models, export formats, previs-grade quality, no public API, waitlist access) and every brief criterion, marked verified / unverified / false with evidence, ranked by impact on adopting Marble in the pipeline. Fix the top three where possible (better import script, scale correction, alignment fix). Then write verdict.md: where Marble fits (environment blockout, previs, VR scouting), where it does not, cost per usable scene from runs.csv, license constraints, and the exit plan if access changes.

Expect: oracles.md with six rows, gap_report.md ranked, verdict.md with cost per usable scene and exit plan.

Audit before moving on: Any oracle without a log, render, or report file is unverified. The verdict must cite numbers from runs.csv and integration.md, not impressions.

4 · Gap analysis and audit

Run this after the build. It makes the agent enumerate its own claims, mark what is verified, rank the gaps and fix the top ones.

You are reviewing a Marble evaluation you did not run. Read product_facts.md, brief.md, prompts.jsonl, runs.csv, validator reports, integration.md, persistence.md, compare.md, oracles.md, gap_report.md, and verdict.md.

1. Enumerate every claim: generation times, formats, splat and triangle counts, validator results, fps, walkability, scale, persistence SSIM, reviewer preferences, license facts, cost per usable scene. Mark each verified, unverified, or false. Re-run the glTF Validator on three GLBs and the Blender import on one scene yourself.
2. List missing pieces: prompts skipped, retries hidden, persistence tested only in the hosted viewer, no scale check, comparator not blind, license unread.
3. Rank by impact on the adopt or not decision: licensing and exportability first, then collider usability, then quality.
4. Fix the top three now and show evidence.
5. Report what you could not fix and why, with the next action.
Return a claim table (claim, status, evidence, fix) and the ranked gap list.

Questions the agent must ask itself before it says done:

5 · What proves it right

6 · Failure modes

7 · Agent direction (unattended runs)

Start with product_facts.md: access, exports, and license decide whether the rest is worth running. Build the harness (validator calls, Blender script, viewer page, Godot project) before spending credits, so every export is checked the moment it lands. Cache all exports under exports/ and never regenerate to replace a weak result. A sub-agent can build the Godot walk-test project and another the three.js splat viewer in parallel while generations run. Generation through the browser needs Victor's account: stop and ask for access and a credit budget before step 3, and ask before uploading any image. Write outputs to docs/marble_eval/: product_facts.md, brief.md, prompts.jsonl, runs.csv, integration.md, persistence.md, compare.md, oracles.md, gap_report.md, verdict.md, with scripts in pipeline/. Return the verdict paragraph, the oracle table, and the gap list.

Prompt system updated 2026-10-22 · all prompt systems · JSON