The editor mode is actually usable

The blueprint lands: from "watching it run" to "reaching in to change it"

The editor blueprint set the day before entered implementation and ran through with no dawdling — a beautiful instance, across the whole project, of "think it through, then build it at once." Before this, Studio was always a place of "you speak, the AI builds, you watch": you describe what you want, the AI writes code, and the right side runs the game; but if any one thing wasn't to your liking, you could only keep describing it in words, unable to nudge it by hand. What this day added is exactly the "by hand" road: select, drag, save — these plainest of actions hold true in Studio for the first time. Meanwhile the engine filled in four or five capabilities underneath to back this road, and the content toolchain let assets flow more smoothly into the editor. In one line: for the first time, creative agency shifted from "all handed to the AI" to "both human and AI can reach in."

Editor mode lands: select, drag gizmos, auto-save

This day Studio gained a real "editor mode" for the first time, built up steadily in two layers. First the "editing surface" was stood up — the editing interface is rendered live by the engine, so what you see is the game's true appearance rather than a separately-drawn approximation; then the "editing brain" was wired in — a command bus threads each of your actions into controllable instructions, paired with a scene tree on the left (listing what objects exist and who is whose child) and a property inspector on the right (select an object to see and edit its properties), plus live sync between editor and engine. In feel: you can click to select objects in the viewport, use a gizmo (that handle wrapped around an object that lets you drag, rotate and scale directly) to adjust position and pose, and drag assets from the asset panel into the scene. This "surface + brain + sync" structure is key — it means the editor isn't a hardcoded panel but a framework that grows alongside the engine's capabilities, and every later editing feature grows on top of it.

Scenes become "document-driven": one per game, auto-following

This day also established something far-reaching: scenes are now "document-driven" — a game's scene is expressed as a structured document, and that document is the scene's sole authority; the editor reads it, the engine runs by it, and saving saves it. Behind this, a dedicated scene core landed as the single source of truth for these documented scenes. Persistence came with it — "one scene per game, auto-saved, following whichever game is open": whichever game you open is the scene file you edit, and data no longer bleeds between games. Why does "document-driven" matter so much? Because it points "human editing" and "AI editing" at the same thing — drag an object and you change this document; the AI writes code and changes this same document; the two are naturally consistent rather than each editing their own copy. This day even the sample shooter template was changed to describe its static arena via this document, validating for the first time, with a real game, that the mechanism works.

Drag in characters and vehicles + jump between plugins

On the content-creation side, this day wired up the "direct upload" path: characters, NPCs and vehicles finished in the character workbench can be dragged straight in for use, and finishing an NPC auto-advances to the next step; several old bugs — not displaying across surfaces, vehicles landing in the wrong spot — were fixed along with it. Further, plugins can now navigate to one another: a click in the character tool, say, can carry the current context straight into the animation tool to keep going, with no hunting for windows or re-confirming which character it was. The animation workbench's four modules were also unified at once into a single design language, with tidy color and spacing, looking like one product rather than four parts bolted together. Together these thread the "make a character → animate it → place it in the scene" flow — which used to mean bouncing back and forth across several tools — into a smooth assembly line, whose endpoint is exactly that just-now-usable editor.

Engine: anti-aliasing + 9-slice UI art, a more refined look

The two engine pieces this day are both visible refinements. One is multi-sample anti-aliasing: without it, an object's slanted edges and outlines carry a fringe of fine "jagged" steps, especially obvious on diagonals and in the distance; with it, edges are softly smoothed and the whole image is instantly a notch cleaner. The other is 9-slice support: a fundamental of UI work — a button or panel's background image, if stretched whole, distorts its rounded corners; the 9-slice approach cuts the image into nine pieces so the "four corners" stay as-is while only the "edges and middle" stretch as needed, letting one image fit buttons and panels of any size without warping. Neither changes gameplay, but they directly decide whether a game "looks refined." Making these basic look-and-feel capabilities solid is the precondition for users' creations to be "presentable" — however good the gameplay, a fringe of jaggies and a distorted button cheapens it at first glance.

Engine: extensible asset formats + no more silent load failures

The engine also made two more "skeletal" changes this day. One: asset importing became extensible. The knowledge of "which format, read how" used to be hardcoded in the engine core, so the engine could only use the few formats it knew; this day that knowledge was inverted out of the core into something injectable from outside — meaning third parties can later teach the engine its own asset formats without touching the engine itself. This turns the engine from a closed "eats only the prescribed ration" system into an open, extensible platform. Two: a built-in mapping from resource ids to internal handles was added, with clearer errors. Before, if a component wasn't correctly defined or a referenced resource couldn't be found, the system often failed silently — the scene looked loaded, yet some object was inexplicably missing and you had no idea where it went wrong; now such cases are reported explicitly. Extensibility lets the engine "grow open," and clear errors let it "be debugged" — both backstops for ever more complex content.

Behind the scenes: preferences follow you + no stale dev cache

The backend also tidied two unglamorous but experience-shaping things this day. One: browser preferences were persisted to the server, so the personal settings you tweak in the interface no longer live only in one browser but follow you, still there when you open up elsewhere. Two: an annoying dev-time phenomenon was fixed — a plugin's entry page used to be cached by the browser, so after changing code and refreshing you'd still see the old version and doubt whether it took effect; this day that entry page was set to not cache, guaranteeing a refresh shows the latest. Individually trivial, such changes decide "how comfortable it is to use": preferences not lost, refresh-is-fresh — seemingly obvious, yet genuinely achieving them takes picking at one spot after another. Smoothing these burrs is the daily homework of a tool moving from "usable" to "pleasant."

What this day means

This day is a watershed: Studio began growing from a "conversational game generator" into a "creation platform with both conversation and editing." What's most worth remembering isn't just the result "the editor works," but how it landed — blueprint one day, running the next, and not an isolated panel piled on but the "document-driven scene" foundation, several engine underlying capabilities, and the content tools' inflow path all aligned at once, so the editor was born standing on a structure that can keep growing. For users, from this day you can have the AI generate while you hand-tune yourself, both pointing at the same scene without fighting. For the platform, this step formally reconnected "human creativity" into the creative loop — the AI takes you from zero to eight-tenths, and you hand-add the remaining, most personal-taste two-tenths yourself.