Fable51-Worlds: Text to Walkable 3D Worlds

Somebody typed a paragraph asking for San Francisco's Union Square, and what came back was a city block you can walk around in a browser tab: 129 storefronts with their real tenants, 220 pedestrians on separate behaviours, Powell Street cable cars, traffic signals on a sixty-second cycle, and the inside of the Apple store. No game engine, no purchased 3D tiles, no downloaded meshes. As a claude fable 3d world generator, fable51-worlds writes the geometry as code, and the code is all in the repo.

PhiloLabs pushed it to GitHub on 2 September 2026. Two days later it had 388 stars, 17 forks and eleven commits, from two contributors: a person and Claude.

What is actually in the repository

Two worlds, as of September 2026. Union Square in San Francisco, and Higashiyama in Kyoto, running from Gion up to Kiyomizu-dera at sunset.

Each is a plain Three.js app. You clone it, npm install, npm run dev, and it opens on localhost:5173. WASD to walk, shift to run, E to interact with things, Tab for an orbit camera, 1 2 3 to switch between day, sunset and night. There's a debug HUD on F1 and a reference overlay on R that fades a real photograph over the render from the same camera position, which is a checking tool rather than a demo feature.

MIT licence. No releases published, no tags, two branches. This is a demonstration repository rather than a product, and it doesn't pretend otherwise.

How the swarm builds a place

The pipeline runs in four moves, and the interesting part is that none of them are "generate a 3D model."

Agents research the location first, pulling street layout and real tenant data. Then they model it, writing code that emits geometry rather than producing mesh files. Then they render and photograph the result. Then a separate set of reviewer agents grades what came out against reference photographs, and the run continues based on what those reviewers said.

The brief that produced Union Square sits in the repo as PROMPT.md, kept verbatim, and it runs to 27 kilobytes of text. There's a FINAL_QA_REPORT.md next to it. Publishing both is the most useful thing this project does, because it turns an impressive demo into something you can read, argue with and copy the method from.

Why the multi-agent framing matters here

Building a city has a verification problem that writing an essay doesn't. A wrong storefront is wrong in a checkable way, and the check is a photograph.

That's why the reviewer step is the load-bearing one. Generation without grading gives you a plausible-looking street where the sign says the wrong thing; generation with an independent grader that compares renders against references gives you a correction loop. Whether the geometry came from a model or a procedural function is almost beside the point.

A run like this is measured in hours, not minutes, and it's mostly unattended: research, generate, render, grade, fix, repeat. That shape is a bad fit for a laptop, which is where MoClaw earns its place in this workflow rather than being name-dropped into it. A hosted cloud AI computer holds the working directory and the process for the whole run, so a closed lid or a dropped wifi connection doesn't cost you the last two hours of grading. If you're new to what Fable 5.1 is doing differently, our explainer on the Fable method covers the reasoning model underneath, and the Opus 5 comparison sets out where each one is stronger.

Inside the brief

PROMPT.md is worth reading even if you never run anything, because it shows what a specification looks like when the executor is a swarm rather than a person.

The work is cut up geographically before anything starts. Five agents take one part of the square each: the plaza itself, the Powell Street side, Stockton, Post and Geary. A separate store census agent inventories what's actually there. Apple Union Square and Nintendo SAN FRANCISCO get their own dedicated agents, with real addresses written into the brief, 300 Post Street and 331 Powell Street, and an explicit instruction not to treat them as generic boxes with logos on the front.

Asset generation is split the same way, into subagents for architecture, street furniture, retail, vehicles and vegetation. Those run Blender as a Python library offline. The brief is blunt that Blender must not appear in the runtime, which is why what ships is Three.js and nothing else.

Buildings get reconstructed in three named passes: massing, then façade structure, then street-level detail. That ordering is doing real work, since it means a wrong shopfront sign gets corrected without touching the block's silhouette.

What makes the whole thing checkable is the last artefact: qa/discrepancies.md, which records what the brief asked for against what actually got delivered. Most demos publish the render. Publishing the gap between intent and result is a different kind of claim, and a much more useful one if you were planning to write your own claude fable 3d world generator prompt. Reading somebody's divergence list is the fastest way to learn where an autonomous build drifts.

Any input, one pipeline

The README claims three entry points into the same machinery, and the distinction between them is worth understanding before you try it.

A text brief names a subject and a style, which can be as unrelated as you like: a real Kyoto street rendered as a hand-painted anime background is the example given. A video brief takes a clip, maybe thirty seconds of a walk-and-talk, and reconstructs the set behind the shot so you can step off the camera path and keep walking. An image brief takes one photograph at any angle and returns the place as geometry, so you can turn around and change the hour.

Style stays open because each world ships its own renderer, written for that world. Nothing is chosen from a list of presets, which is the reason a cel-shaded plate and a photographic reconstruction can come out of the same pipeline.

What you can and can't do with it today

The Union Square build is dense in a way that's easy to underrate: 23 interactive objects including doors that open as you approach and question blocks that bounce and drop coins, 109 vehicles, Muni buses, two full interiors across multiple floors, and lit shopfronts at night with street-lamp pools on the pavement.

What you can't do is feed it your own brief and get a world back. There's no hosted generator, no CLI, no npx create-world. What's published is two finished worlds plus the prompt and QA report that produced one of them. Treating that as a system you can run is a misreading; treating it as a documented method you can adapt is exactly right.

Reproducing the method is where the setup cost shows up, and it isn't the model access. It's the rest: Blender driven as a library, a headless render path, enough disk for the reference photographs and the baked assets, and a machine you're willing to leave running while agents grade each other's work. Nobody wants that stack on the laptop they take to meetings. MoClaw is one way around that, since a hosted cloud AI computer gives the toolchain its own machine to live on and leaves your own install alone.

The roadmap points at two extensions: motion as code, with shot lists and camera continuity held across sequences minutes long, and worlds as training environments where the same code that builds the place supplies the reward signal. That second one is the ambitious one, and it's also the one that makes the choice to generate everything procedurally look deliberate rather than showy. A world made of code can be inspected, mutated and scored. A downloaded mesh can't.

The honest limits

Browser performance is the obvious ceiling. Three.js and WebGL running 220 pedestrians with individual behaviours plus 109 vehicles plus two interiors is a lot to ask of an integrated GPU, and neither world publishes a hardware baseline. Try it before promising anybody a demo.

Then there's provenance. The repo is two days old, the tenant data is described as 2025 to 2026, and nothing here has been through a correction cycle in public. The QA report grades against photographs, which is a real check, but it's the project's own check.

And a general caution about anything this fresh: eleven commits and no releases means the API surface, if you can call it that, is whatever was in main this morning. Fork it if you're building on it.

For the run itself, budget for the compute rather than the wall clock. Multi-agent research, procedural generation, offline asset baking with Blender driven as a library, render passes and a grading loop are all things you can start and walk away from, and MoClaw exists so that walking away doesn't mean starting over: the cloud machine keeps the agents working while you sleep, which is the only sensible way to run an overnight world build.

FAQ

Do I need a Claude Fable 5.1 subscription to use this?

Not to walk around the two worlds that ship. Those are plain Three.js apps: clone, install, run. You'd need model access to reproduce the build pipeline yourself, and the repo doesn't publish a runner for that anyway.

Can I export the 3D world?

Not as a model file. Every building, sign, tree and traffic light is generated by code in the repo, so the source is the export. That's better for editing and worse for dropping into Blender, and it's the trade the project made on purpose.

Does it run entirely in the browser?

The finished worlds do, once the dev server is serving them. Generating a world doesn't: the research, modelling and grading run as agents outside the browser, with assets baked offline before they reach it.

How accurate is the Union Square reconstruction?

Accurate enough to check against photographs, which is the standard the project set itself. 129 storefronts carry real tenants, addresses and status, and the reference overlay fades a real photo over the render from the same camera. Treat the tenant data as a snapshot rather than a live feed.

Is a claude fable 3d world generator useful for anything besides demos?

The roadmap's answer is agent training environments, where a procedurally built world supplies both the scene and the verification signal. Today the practical use is narrower and still real: reading PROMPT.md to see how somebody specified an eight-hour autonomous build and got a gradeable result out of it.