World building

What is world building?

It's what we do instead of laying out screens. We take what an app can do and we put it somewhere — abilities become places, background work becomes characters, features become things in their hands. Every world we build belongs to one app, and it isn't a picture of that app sitting next to it. It is that app's interface. You don't open it. You play it.

Luma World's home planet. Drag to turn it.
The problem

Software you have to describe to.

Three shapes cover almost everything on your machine right now, and all three ask you to put into words a thing you cannot see yet.

A text box

The cursor blinks and it's on you to know what to type. Then you wait. Whatever it did while you waited happened somewhere you weren't, and what comes back is a wall of text you have to read to find out how it went.

A stack of screens

Sidebar, tab, panel, settings page. You learn it by clicking everything once and remembering where things were. Nothing in there is anywhere — it's all open at the same time, which is why a menu is the only way back to any of it.

A wizard

Step one of six. Next. Next. You describe the thing by filling in a form about it, and you find out at the end whether you meant what you typed. The bar was full the whole time and told you nothing.

The turn

A world instead of an app.

A world is a place. It has ground, a way in, somewhere further to go, and something going on in it whether you're looking or not. That is the whole difference: an app is open, a world is somewhere you are.

So we stop asking what the screen shows and ask where you're standing. An ability becomes a room you can walk to. Work that used to run in the background becomes someone doing it in front of you, with their own tools in their hands. A tool becomes a thing that lives in a particular place, and going to get it is how you use it. Nothing needs to hide behind a menu, because a menu is what you build when the abilities have nowhere to live.

And every world is built for ONE app. Not a lobby in front of it, not a 3D theme over it — the world is where the app's work happens, and walking around in it is how the work gets done.

The story

A story instead of a wizard.

Nobody fills in a form to find out what happens next in a game. They play, and the game tells them where they are and what's worth doing next. That's available to software too. It costs nothing but the decision to stop numbering the steps.

So the steps become scenes. Instead of step three of six you meet someone who wants something from you, and what you'd have typed into field three is a thing you say to them. You get to the same place. You arrive having done it rather than having described it.

Progress stops being a bar, too. Progress is what happened — who you met, what got built, which room opened — so you can tell how far in you are by looking around, the way you can in any place you've actually been.

The story belongs to the world, not to a tutorial pasted over it. Luma World's is the Architect's and the Lumas' — who they are, what each one is for, and the tools that belong to them. The Circle is one of those tools.

The worked example

How Luma World is built.

Luma World is the one we can show all the way through, because it's the one we spend our own days inside. It's a virtual office you open on your computer. Here it is in the order you meet it.

You start above a planet

The first screen is a globe you can turn, with cities on it at fixed points and names on the cities: MIYAKO is the capital, and ZEN GARDEN, IRODORI, MINATO, TAKAMINE and HOSHIMORI are the rest. Picking where to work means turning the world until you find it. That is the top-level navigation, and it is a planet.

A city is a field of temples

Inside a city stand the buildings, as temples. One building is one place work happens — a project, a team, a thing you're making. You choose one the way you choose a door, by going up to it, and it opens.

The building opens into an office

There's one office and it's a zen garden: a pond with koi in it, a torii, a path of stones, lanterns lit at blue hour, rain on the roof of the studio at the edge. The desks stand in a ring in the middle of it. This isn't a picture that loads before the real screen. It is the real screen.

Your agents are the people in it

Each agent arrives as a Luma — a small figure at a desk with a monitor in front of it, and what's on that monitor is what the agent is actually doing. You read it over its shoulder. A room of people is legible from the doorway in a way a scrollback never is, so you can see which one has stopped moving before it tells you it's stuck.

The Architect builds one thing with you

One figure in there is drawn in pencil scribble and isn't a Luma. It's the one you talk to. You say what you want to build; it answers out loud about a second after you stop speaking, and you can talk over it. While it talks it draws the design across the whole scene, and it goes and looks — opens a file, runs a command in the project you're discussing — mid-sentence, without the conversation stopping.

You build one component with it properly. Not a spec of one. The thing.

Then it turns round and starts everyone else

A conversation you keep becomes a design on disk, and a design becomes a brief. The Architect takes a desk in the office like anyone else — a body in the room, a row in the sidebar — and hands that brief to the agents who build the rest. The one component you built together is the example the rest is built from.

And the Circle is where they disagree

Deciding is not doing, so it has its own room. The agents leave their lit desks and walk to a ring, and the first thing a meeting costs is the work they put down to come. One lantern is the turn: whoever holds it has the floor, and it lifts away when their time runs out whether they'd finished or not. Above the table hangs the plan — small, mostly empty, and hard to add to. You sit in the ring with them, not outside it.

The principles

What this asks of us.

Building this way is slower than laying out screens and it rules things out. These are the five we keep coming back to when a call is close.

AI you can see

If it matters, it happens where you can watch it. The AI is a character you interact with. It has its own tools, its own place and its own way of working, and what it's doing is in front of you while it's doing it. Work that only shows up in a log afterwards was invisible during the whole part where you could still have changed it.

A place before a screen

The first question about anything new is where it goes, not what it looks like. Something that can't be put anywhere is usually not a feature yet — it's a setting, and settings can wait in a drawer. A world stays walkable only as long as everything in it has an address.

Play before typing

A text box asks you to already know the words. A place doesn't: you can go over and look at a thing to find out what it is. We take the extra work so that your first move is something you do rather than something you have to phrase, because nobody is at their most articulate on the way in.

Characters before logs

A log tells you what happened. A character tells you how it's going, at a glance, while it's still going. That's why the agents are characters with tools of their own and the meeting is a room with a lantern in it — you read a posture across a room faster than you read a status field, and you do it without deciding to.

The story is the onboarding

There is no tour, and there's no step one of six. You learn the world by being in it, in the order things happen — the Architect early, because it's who meets you and there's nothing to orchestrate yet; the Circle later, because it only makes sense once there are enough of them to disagree. Everything a tutorial would have told you is somewhere you were going to stand anyway, said by someone who has a reason to say it.

Go and see

Reading about a place is not being in one.

Luma World is the world we build in and the one you can walk into. It's out now for macOS, Windows and Linux.

See Luma World Back to Pixel City