作者以 World Labs Atlas Chisel 打造莫卧兒—都鐸宮殿,實測其 3D、遊戲與影片用途
I Built a Ghibli-Style Mughal-Tudor Palace With World Labs Atlas (Chisel). Here's What It Can Do for 3D, Games and Video
作者以 World Labs Atlas 的 Chisel 製作莫卧兒—都鐸宮殿,展示同一 3D 佈局如何生成風格一致的多視角圖像、鏡頭影片及 3D Gaussian splat。
文章以同一座可編輯 3D 宮殿對照文字生成影片工具,展示共用場景佈局對多鏡頭一致性的作用,並交代 splat 轉網格供遊戲使用仍需清理。
Last week World Labs opened Atlas, its world model, to everyone. I wanted to see what it could actually do, so I gave it a hard brief: an architectural mash-up that doesn't exist anywhere in its training data, in a hand-painted animation style, with a camera move I could turn into video.
This post covers what I made, how the tool works under the hood, where it fits for 3D scenes, games and video, and how it compares with the other options in 2026.
TL;DR: Atlas's Chisel app takes a prompt, builds a rough 3D blockout of your scene with an AI agent, then "paints" that geometry into consistent images, camera-path videos and an explorable 3D Gaussian splat. Because every output comes from the same 3D layout, the palace looks the same from every angle and in every frame. That's the big difference from text-to-video tools.
What is Atlas?
Atlas is World Labs' new world model (World Labs is the spatial-intelligence startup co-founded by Fei-Fei Li, and the company behind Marble). It was announced in September and opened to the public on November 12, 2026, with two web apps and an API:
| Tool | What it does |
|---|---|
| Viewfinder | Starts from images. It can build a plausible scene around a single photo, or reconstruct a real space from up to 64 photos. Then you move the camera, set paths and render. |
| Chisel | Starts from geometry. You (or an agent) block out the scene from planes, boxes and basic shapes, style it with text or reference images, and every camera view updates as you edit. |
| Splats to Mesh | Converts Gaussian splats into polygon meshes (GLB) for games, Blender and engines. |
| Relight | Changes the lighting of a splat scene. |
| API | Endpoints such as atlasGenerate, atlasChisel, atlasMasked, images2PosedRGBD and splats2Mesh. |
Outputs are keyframes (stills), video clips, and 3D Gaussian splats exportable as .spz or .ply.
I used Chisel for this experiment.
The experiment: a Mughal-Tudor palace in a Ghibli valley
Here's the prompt I started with:
A vast outdoor Ghibli-style animated landscape: snow-capped mountain ranges in the distance, rolling lush green meadows and hills below with wildflowers, soft painterly clouds and warm golden light. On a hilltop stands an ancient Mughal-style palace blended with Tudor architecture: red sandstone walls with half-timbered Tudor gables, granite foundations and terraces, white marble domes, chhatris, arched jharokha balconies and minarets, with a winding stone path and gardens leading up to it. Hand-painted watercolor look, whimsical and serene.
I deliberately picked something hard: two architectural vocabularies that never meet in the real world (Mughal domes, pishtaq arches and chhatris on one side; Tudor half-timbered gables and jettied upper storeys on the other), a painterly style, and a big outdoor landscape with depth.
Step 1: The agent plans and blocks out the scene
Chisel has a built-in agent (you can pick the model; mine ran on "Gemini 4 Argon" from the model picker). It doesn't jump straight to pixels. It reads the prompt and the reference image, then writes a step-by-step build plan:
- Valley terrain, distant snow-capped mountains, hilltop palace massing
- Scene cameras and render prompts
- Mughal marble core: dome, pishtaq arch, minarets, chhatri
- Tudor half-timbered wings
- Terraced Charbagh gardens, reflecting pool, winding path
- Trees, topiary, wildflowers, clouds
- Final camera and layout verification
Then it builds actual 3D geometry for each step: walls, domes, booleans for openings, curves for paths and tree avenues, scatters for 95 wildflower clusters.
Under the hood, every camera view starts as plain geometry. These are two of the masks Chisel produced from the blockout, before any style was applied:

The palace blockout as a silhouette mask: Tudor wings, minarets and the onion dome.

A low-angle mask of the central dome. This shape is what Atlas "paints" into marble in the final render.
The finished blockout had:
- a 420 m valley terrain with a 280 m distant mountain range
- 82 × 30 m stepped granite and red sandstone bastions with corner turrets and arched undercroft vaults
- a 20 m marble hall with a pointed-arch pishtaq portal and an 18 m onion dome with a lotus finial
- 28 m minarets with balcony galleries and domed lanterns
- a domed chhatri pavilion on a 9.7 m arcade
- four steep Tudor gabled wings with timber framing, casement windows and brick chimneys
- terraced Charbagh gardens, a reflecting pool, an 8-step stone staircase, a 140 m winding stone path and an Italian cypress avenue
- a 130 × 65 m cumulus cloud bank behind the roofline
Step 2: The agent checks its own work (a lot)
This was the most interesting part to watch. After each step the agent takes a capture from a camera, inspects it, runs a layout check and fixes what's wrong. Some real examples from my session log:
- The first camera missed the hilltop entirely. The default terrain was nearly a kilometre wide, so the agent tightened the valley.
- The palace came out mirrored left-to-right compared with my reference painting. It flipped the marble core, minarets and chhatri to match.
- Floating parts: the layout check flagged a minaret onion cap floating 67 m above its tower after a group origin shift, plus timber bands hidden inside walls. The agent re-seated the domes and deleted the hidden boxes.
- A cypress tree standing inside the reflecting pool. It took several tries: the agent rerouted the tree avenue's guide curve around the pool court, accidentally deleted the trees with the old curve, replanted them, then moved them clear of the terrace wall.
- Tudor wings overhanging thin air past the edge of the bastion. The agent tried adding piers, then moved the wings, then finally extended the bastion's north-west corner so the walls actually support the buildings.
- Duplicate cameras: a shot check found 7 cameras sharing 78 to 95% of their frame with another camera. The agent deleted them and used auto-camera placement to get 8 distinct views.
This self-correcting loop is what makes Chisel feel like a junior 3D artist instead of a slot machine. It isn't perfect (two runs timed out on the model and I had to hit Continue), but every fix is grounded in actual 3D geometry, so it sticks.
Step 3: Render stills from the 3D layout
With the blockout done, Chisel renders each camera through Atlas using render prompts. The agent wrote three lighting variations:
- Warm golden morning
- Glowing amber sunset
- Bright midday
with geometry adherence set to "fine" so the arches, domes and timbered gables keep crisp profiles. Iteration 3 ("Bright midday") gave me 8 renders at 1280×720, one per camera:

Establishing valley view. The grey bastions became red sandstone, with the marble pishtaq, Tudor wings and terraced gardens below.

Mughal marble dome next to Tudor gables: the two architectural styles meeting on one terrace.

Three-quarter view of the bastion, with the minarets, dome and Tudor wings on the upper deck.

East Tudor wing on the sandstone bastion, with snow-capped peaks in the distance.

The upper garden gateway, looking up at the marble facade and a Tudor wing.

Boxwood parterre terrace, stone stairs and the winding path, with the mountain range behind.

The winding stone path climbing past the reflecting pool toward the palace.

The Charbagh reflecting pool. That cypress the agent kept moving is finally out of the water.
What impressed me: the grey boxes became red sandstone, white marble and timber framing, the hill became a wildflower meadow, and the watercolor style held across all eight shots. The minarets are in the same place in every image because they come from the same 3D layout.
Step 4: A camera path becomes a video
Then I asked the agent in plain English:
i want a camera path which shows the front view of the palace to render video
It read the existing camera paths, noticed the active one cut through the western hillside and trees, and replaced it with a front approach that glides over the winding path and Charbagh gardens while keeping the bastions, Tudor gables and central dome centred. It sampled frames along the path to check ground clearance, found the last keyframe clipping the chhatri, and pulled it back wider.
The result: a 240-frame fly-through at 24 fps (10 seconds), which you can export as MP4 or GIF at 8/12/24/30 fps.

The 10-second front-approach fly-through rendered by Atlas, compressed to a GIF for this post.
You also get a keyframe timeline with easing curves, so you can tune the camera speed by hand like in a normal animation tool.
Step 5: A real 3D world (Gaussian splat)
Finally, the output panel offers Splat creation (5,000 credits in my session). This turns the generated views into a 3D Gaussian splat, a scene made of millions of tiny coloured, semi-transparent blobs that renders in real time in a browser or engine. You can download it as .spz (compact) or .ply (wider compatibility).
Total hands-on input from me: one prompt, a reference image, one sentence asking for a video path, and a couple of "Continue" clicks.
What you can use this for
1. 3D scenes and previsualization
- Concept and previz: block out a set, try three lighting moods, and get consistent frames from any angle in a session instead of weeks.
- Architecture and spatial design: Viewfinder can reconstruct a real space from photos, and Chisel can explore massing and "what if" designs.
-
Blender: World Labs ships Blender integration, and
splats2Meshexports GLB with controls for region, max face count, and textures vs vertex colours vs untextured.
2. Games
- Graybox → art pass in one step: this matches how level designers already work. Graybox the level in Chisel, let Atlas fill in the art, convert splats to a mesh, and bring it into your engine.
- Backdrops and skyboxes: splats work well for distant vistas like my mountain valley, where you need beauty more than collision.
- Web games: World Labs' open-source Spark renderer draws splats in three.js. A minimal example:
import * as THREE from "three";
import { SplatMesh } from "@sparkjsdev/spark";
const scene = new THREE.Scene();
const camera = new THREE.PerspectiveCamera(60, innerWidth / innerHeight, 0.1, 1000);
const renderer = new THREE.WebGLRenderer();
renderer.setSize(innerWidth, innerHeight);
document.body.appendChild(renderer.domElement);
// the .spz you downloaded from Atlas
const palace = new SplatMesh({ url: "./palace.spz" });
scene.add(palace);
renderer.setAnimationLoop(() => renderer.render(scene, camera));
- Prototyping and pitching: show a publisher or your team a walkable mood piece before you build anything.
Caveat: splats are not game-ready geometry on their own. For gameplay you'll want the collider/mesh export, and expect some cleanup.
3. Video and film
- Consistent B-roll and establishing shots: the camera path is fully directed (keyframes, easing, lens), not "hope the model moves the camera the way I asked."
- Same world, many shots: you can render a wide, a close-up and a fly-through that all agree with each other. That's very hard with text-to-video.
- Lighting variants: one layout, three moods (morning, sunset, midday) from render prompts, plus the Relight tool.
- Social content: MP4/GIF export is built in.
4. Developers and agents
The same endpoints the apps use are available over HTTP:
curl --request GET \
--url 'https://api.atlas-beta.worldlabs.ai/api/v2/assets/<asset_id>' \
--header "WLT-Api-Key: $WLT_API_KEY"
Useful endpoints include atlasChisel (layout → images), atlasMasked (edit only one region), images2PosedRGBD (camera poses + depth from photos) and splats2Mesh (GLB export). This opens up pipelines like "an LLM writes the layout → Atlas renders it → splat to mesh → drop into the engine."
How does it compare with the alternatives?
| Atlas (Chisel / Viewfinder) | Text/image-to-video (Veo, Sora, Runway, Seedance) | Real-time world models (Genie 3, Oasis, Odyssey) | Image-to-3D object tools (Meshy etc.) | Manual 3D (Blender / Unreal) | |
|---|---|---|---|---|---|
| Output | Stills, video, 3D splat, mesh | Video clip | Interactive stream | Single 3D objects | Anything |
| Consistency across shots | High: all from one 3D layout | Low to medium: each clip re-imagines the scene | Medium: can drift or forget after a while | n/a | Perfect |
| Camera control | Exact keyframed paths | Prompted or limited | Live (keyboard/mouse) | n/a | Exact |
| Layout control | Graybox geometry + agent | Text prompt | Prompt/image | Per object | Full |
| Exportable 3D asset | Yes (SPZ/PLY/GLB) | No | Mostly no | Yes (objects only) | Yes |
| Time to first result | Minutes to hours | Minutes | Seconds | Minutes | Days to weeks |
| Skill needed | Low | Low | Low | Low | High |
Why Atlas is better for this kind of work
- It's 3D first, not pixels first. Video models generate frames that only look 3D. Atlas generates from an actual spatial layout, so my palace's minarets, gateway and pool are in the same place in every shot. If you need more than one shot of the same place, this matters a lot.
- You control structure, not only style. Graybox geometry is a much stronger constraint than a paragraph of text. "Put the chhatri on the western terrace, 14 m wide" is something you can place, not just ask for.
- It leaves the browser. Splats (SPZ/PLY) and meshes (GLB) go into three.js, Blender, Unreal and Unity pipelines. Most video tools and real-time world models end in a video file or a stream.
- The agent does the tedious QA. Floating parts, intersecting meshes, duplicate cameras and blocked sightlines were all caught and fixed automatically.
- One model, many inputs. Photos (Viewfinder), blocks (Chisel) or the API all feed the same model, so you can mix real reconstruction with invented content.
Where the alternatives still win
To be fair:
- Real-time interactivity: Genie 3-style models let you walk around and act in a world at interactive frame rates. Atlas is about authored scenes and renders (World Labs does show a real-time research preview at up to ~15 fps).
- Motion and characters: video models are far better at people, animals, water and anything that moves. Atlas scenes are mostly static environments.
- Production-ready geometry: splat-to-mesh output still needs cleanup for gameplay. Hand-built assets in Blender/Unreal are still the gold standard.
- Maturity: Atlas is new. There's no paper or model card yet, the benchmarks are vendor-reported, the API still carries beta labels, and refined splats cost real time and credits. During my session, two agent runs hung on the model and needed a manual Continue.
- Prompt sensitivity: Chisel's results depend a lot on your prompt and reference image quality.
Tips if you try it
- Give it a reference image. The agent compared every capture against my painting, which is how it caught the mirrored palace.
- Be specific about materials and architecture. Words like "pishtaq", "chhatri" and "jettied upper storey" produced noticeably better geometry than "fancy palace."
- Let the agent finish its checks. The shot check and layout check catch issues you'd otherwise only spot in the final render.
- Ask for camera paths in plain English. "Front view of the palace for a video" was enough.
- Render several lighting moods before you spend credits on a splat.
- Plan for credits. A refined splat was 5,000 credits in my session.
Final thoughts
What sold me on Atlas wasn't one pretty image. AI image tools have done that for years. It was getting eight pretty images, a 10-second fly-through and a 3D world that all agree with each other, built from a layout I could inspect and edit.
For game prototyping, previz, environment concept art and consistent video B-roll, that's a real workflow change. For final game assets and anything with characters in motion, you'll still pair it with traditional tools and video models.
If you try it, I'd love to see what you build. Drop your scenes in the comments! 🏰
Built with World Labs Atlas (Chisel), November 2026. All renders and video are my own outputs from the session described above.
來源:DEV Community · dev.to