Multiple levels per project + a shadow-system upgrade

Growing bigger while tightening up

The day's work splits into two forces: "growing bigger" and "tightening up." On the growing side: a project can hold multiple levels, lifting the unit of creation from "one scene" to "a whole set of a game"; the engine's shadows, HDR and bloom stepped up at once, meaning visuals can push another big step toward realism and texture; and the bullet-survival sample became a complete two-level campaign, demonstrating these new capabilities on the spot. On the tightening side: both the engine and the chat hunted the invisible enemy of "resource leaks," plugging spot by spot the video memory and memory that weren't returned after use; agent reliability also got a focused hardening so it can retry on error and withstand very long context. A platform growing fast must tighten its foundation in step, or the bigger the scale, the more the holes. This day happened to do both at once.

Multiple levels in one project + a level launcher

This day the editor gained "multi-scene games," a key change that enlarges the unit of creation. Previously a project basically mapped to one scene, making a complete game with multiple branching levels awkward; now multiple level files can coexist in one project, and the asset panel organizes "sub-assets" by name rather than stacking the same scene into dizzying duplicate rows. A level launcher panel was added so you can pick which level to enter for editing or play right in Studio; edit and play stay paired in sync, so whatever you change in the editor shows up faithfully on switching to play. To make this capability concrete, the bullet-survival sample became a real multi-level campaign — one level a daytime pasture, one a night graveyard, two entirely different moods — a hands-on demonstration of "build a whole set of levels in one project." From this day, building a complete game with a beginning-middle-end and multiple levels is finally structurally natural, no longer needing a separate project per level manually stitched together.

A shadow upgrade: crisp near, smooth far, point lights cast too

The engine's shadows stepped up a level this day, and shadows are exactly what decides whether a 3D image is "believable" — without them, objects seem to float in air or stick to the background, with no sense of solidity. A core addition was "cascaded shadows," set as the unified approach. It solves the perennial problem of large-scene shadows: covering a big map with one fixed-resolution shadow map blurs either the near or the far; cascaded shadows split the view into segments by distance, high resolution up close and lower far away, so shadows at your feet are crisp and sharp while distant ones transition smoothly, and the whole big map holds up. The other addition is that point lights can now cast shadows — previously only sun-like directional light produced shadows, while a bulb or a torch radiating in all directions cast none; now they too throw correct shadows spreading all around. With complete HDR (high dynamic range, for more realistic light-and-dark gradation) and bloom examples, the overall realism rose. These are the indispensable graphics foundation for building believable real scenes from here.

The bullet-survival sample: from "it runs" to "looks like a real game"

Around that bullet-survival sample, this day thoroughly straightened out the whole particle-and-effects chain, polishing it from "it runs" into "looks like a real game." A string of concrete work: the particle system was changed to an instanced approach, so sparks, explosions and light effects filling the screen at once no longer stutter; additive blending and transparent rendering were fixed, eliminating the blackened squares that used to appear at effect edges; shockwaves went from a messy blob into clean thin rings; each skill got its own custom shader, giving explosion, fire and ice their own feel; topped with a layer of cinematic post-processing, and a full set of appearance assets for the monsters and player character. The value is twofold: on one hand, the sample itself became a good-looking finished product you can play directly or learn from; on the other, it actually stress-tested, end to end, the whole set of graphics capabilities the engine had just upgraded that day — shadows, bloom, particles, effects — with a real game. Only by holding it up is it proven that these underlying capabilities are genuinely usable.

Hunting resource leaks on both ends

This day had a hidden thread running through front and back: hunting "resource leaks." A leak is resources used but not returned in time, piling up until they drag the whole system down — inconspicuous in normal use, erupting only under long, large-scale use, and thus especially insidious. On the engine side, complete lifecycle management for GPU resources was added: every video-memory buffer and texture can be explicitly destroyed and reclaimed after use, and the renderer as a whole can release cleanly — previously this video memory might quietly leak, filling up over a long run. On the chat side, several front-end state memory leaks were cleared at once: when a session is closed, the various caches, listeners and temporary records tied to it are correctly evicted rather than lingering in memory and piling up. The two seem unrelated — one in low-level rendering, one in the front-end interface — but the core is the same principle: whoever requests a resource is responsible for returning it after use. Enforcing this principle in every corner of the system is the fundamental guarantee that software can run stably for a long time at large scale.

Agent-reliability hardening: it can retry on error and withstand long context

This day also gave agent reliability a targeted hardening pass, focusing on the classes of problems that most affect "whether the AI is dependable at work." First, retry of large-model calls was added inside the agent's work loop: a model call occasionally fails due to network jitter and the like, and where one failure used to break the whole task, it now retries itself within the loop, absorbing such sporadic faults. Second, when the conversation context grows too long and nears the model's capacity, the system proactively and reactively compresses the history, avoiding hitting the limit and crashing. Third, the callback handling when delegating a task to a sub-agent was hardened, along with reporting of event backlog. These changes came with a dedicated verification means — a scriptable "fake model server" simulating various abnormal situations, validating each hardening in a real running stack. A platform that has the AI work autonomously for you over long stretches most fears it quietly stalling or crashing midway on some sporadic problem; reinforcing these weak links one by one is exactly the confidence that lets people dare to "let it run."

What this day means

This day placed "ambition" and "assurance" side by side. Multi-level projects and the shadow upgrade represent ambition — letting the platform carry more complete, grander, better-looking works, raising the creative ceiling once more; while the leak hunt and agent-reliability hardening represent assurance — letting these bigger ambitions rest steadily on a foundation that doesn't leak, doesn't crash, and self-heals on error. A product chasing ambition without assurance collapses the harder the bigger it grows; one guarding assurance without daring ambition stays in place forever. A truly mature engineering rhythm has the two pace each other as they did this day: every big step forward in capability is matched by tamping down another layer of foundation. The sample made into a complete two-level campaign with refined visuals is the best footnote to this rhythm — it both shows how good it can get and, by running itself, proves whether all of it is truly stable.