A build-gate so the AI can't fake "done"

Making "done" a verifiable thing

Handing game development to an AI raises an unavoidable, fundamental question: how do you know its "done" is really done? People instinctively trust "if it says complete, it's complete," but an AI isn't always reliable — it might declare success right after editing code, only for you to open a black screen. The day's main line solves this trust problem mechanically: no longer letting the AI "be the judge of itself," but gatekeeping with an objective, machine-executed check. Seen alongside the same day's batch of engine enhancements, the two are complementary — the build-gate guarantees "what it delivers actually runs," while the engine enhancements guarantee "what it can deliver is richer, bigger and better-looking." One is the floor of quality, the other the ceiling of capability; pushing both forward is what makes the platform both "dependable" and "capable."

A game build-gate: no "done" until it actually compiles

The AI building games here used to have a headache-inducing flaw: it would declare "complete" after editing code, only for the browser to open a black screen, or for the code to not compile at all — you thought you got a playable game but actually got a pile of code that won't run. This day installed a build-gate across the whole flow: the backend added a build-preflight step that genuinely compiles the game before the AI declares completion; and a hard rule was baked into the AI's charter — it may only declare done once the build passes. Blocking alone isn't enough; the key is letting the AI fix it itself: the specific build errors are forwarded in real time to where the AI can see them, feeding back the detailed cause instead of a cold "it failed." So a complete self-correcting loop took shape: create game → AI writes code → backend runs build → failure yields specific errors → AI fixes against them → until it truly passes. The far-reaching significance: it turns "done" from an AI's subjective claim into an objectively verifiable fact — when it says "it's ready," you can trust that far more confidently.

Multi-material models: each part finally gets its own material

The engine added a key capability for handling complex models this day: a model can contain multiple "sub-meshes," each with its own material slot. It sounds abstract but the use case is very concrete — on a character, armor is metal, clothing is cloth, the face is skin, their texture, reflectivity and color entirely different; on a car, the body is painted, the windows glass, the tires rubber. Previously a model could often only wear one material as a whole, flattening these per-part differences so it looked either all-plastic or all-metal, badly distorted. Now the engine can split a model into multiple sub-meshes by part and assign each its own material, so complex models finally render correctly with "each part its own material." Several model-import bridging bugs were fixed alongside, and all the real sample games completed the data-format migration to match. For creators this means the detailed models imported from outside can be presented correctly as they were meant to look, rather than forced into one uniform material.

More lights, bigger scenes: raising the ceiling on scale

The engine also raised the ceiling on "how big a scene can be" from two directions this day. One is lighting: rendering moved to a "clustered lighting" approach — its core idea is to slice screen space into many small cells and, for each cell, compute only the few lights that actually affect it, so one scene can hold far more light sources than before without crushing performance. A nighttime city, a block full of neon and street lamps, needs exactly the simultaneous presence of many lights, and this pipeline opens room for such scenes. The other is capacity: the render buffers holding object data were changed to "grow on demand by doubling" — previously a scene's object count had a hard cap of roughly a thousand, beyond which it broke; now the buffer automatically expands by multiples as objects grow, the cap is lifted, and large scenes can hold much more. Both are under-the-hood work users don't see yet that directly decides "how big your ambition can go" — not a specific gameplay feature, but the precondition that turns "a grander scene" from impossible into possible.

A more intuitive way to write a game's entry point

The engine also reorganized this day how "creating a game application" is written, splitting it into a more intuitive three layers: one for the camera and basic display settings, one for build/packaging options, one for how resources are wired in. Previously these differently-natured parameters were mixed together and easy to confuse — especially for the AI that relies on it to write code, the messier and less clearly-categorized the parameters, the higher the chance of error. Split by responsibility into three clear layers, what each layer does is obvious at a glance, so the AI writes games more smoothly and less error-prone. This and the day's "build-gate" are really two sides of one coin: the gate guards the exit, blocking faulty output; making the API more intuitive lowers the chance of error at the entrance. A platform that has the AI write code needs both to verify after the fact and to make it harder to err beforehand — together they steadily raise output quality. The default new-game template was upgraded too, shipping out of the box with an HDR sky and a controllable character, so every new game starts from a more presentable baseline.

The editor shows real geometry + steadier replay

The editor moved a step closer to what-you-see-is-what-you-get this day: it now preloads model files, so the edit view directly shows a model's real geometry rather than a temporary placeholder box. It seems like a detail but the impact is real — when you place, align and adjust an object in the editor, you see what it actually looks like, instead of imagining what a box standing in for it will eventually become. The underlying asset pipeline also moved to the engine's native scene-pack format, and the edit view likewise carries an HDR sky, aligning the editing environment further with the final runtime. On error, the on-canvas overlay expands the more detailed underlying cause rather than a generic message, for quick diagnosis. Chat replay also fixed the interleaving order of cross-agent cards — when you review a stretch of history, the back-and-forth between multiple AIs is woven back together correctly, exactly matching the order you saw live. Together these serve one thing: making what you see in the editor, and in replay, as close to real as possible.

Charting the team's progress

This day also added visualization charts for the team's work progress. As more and more work is pushed forward in parallel by AI agents, "where exactly are we now, and how much is left" becomes a question that needs to be seen. The added throughput and burn-down curves chart this information as dual lines accumulating over time, paired with a project-metrics panel, so the team sees the overall pace at a glance: how much was completed in this stretch, how much is still in flight, whether the speed is accelerating or slowing. For a development flow heavily reliant on automation, this "global visibility" matters greatly — though people hand much concrete execution to the AI, they must keep a grip on the overall situation, knowing in what direction and at what speed things are moving. Charting progress is precisely a means to step back from the tangle of execution details while still holding the big picture steady.

What this day means

The day's two main lines together answer two facets of the core proposition "how to make an AI reliably build good games." The build-gate answers "reliable": through objective build verification and specific error feedback, it turns "done" from empty words into a fact that can be verified and self-corrected — the cornerstone of trust. The engine's series of enhancements answer "good": multi-material makes models more real, clustered lighting and expanded capacity make scenes grander, a more intuitive entry makes the AI err less — the expansion of capability. What an AI-driven creation platform most fears is "looks impressive but delivers unreliably"; and this day firmed up exactly the two most fundamental things at once — "dependable" and "well-made." When the machine is both more capable and more strictly verified, people can truly, confidently entrust "building a game" to it.