Full bilingual UI + complete devtools panels

Facing the world, and facing debugging

This day faced two directions. One outward: fully bilingualizing the whole interface so it no longer serves only Chinese users but can face the whole world — a necessary step for a product reaching a broader audience. The other inward: completing the devtools so creators debugging their own games can clearly see console output, network requests and runtime logs — the confidence of being able to "see what you're doing." Outward and inward seem unrelated, but the core is the same: both remove the barrier of "can't see / can't understand." A language barrier makes the interface a wall; no way to debug makes a problem a fog. This day tore down both kinds of barrier at once. Meanwhile, the engine fixed the multi-day shadow problem at the root, added a more orderly way to schedule game logic, and set stricter rules for its own resource management. More reachable outward, more transparent inward, more solid underneath — these are the day's three facets.

Switch the whole interface between English and Chinese in one click

This day did a thorough internationalization, and did it carefully. Step one was a lightweight multilingual core: English as the baseline source (all copy authoritative in English), Chinese as an overlay (replacing English where present), switchable anytime. Step two migrated the whole interface into this system file by file, in batches — top bar, dashboard, chat panel, settings drawer, sidebar, the various switchers, dozens of panels and components, none left out. Why "file by file" rather than all at once? Because hardcoded copy is scattered across hundreds or thousands of spots in the interface, and only going through each one misses nothing. After migration, the interface defaults to English, follows the system language automatically, and got a thoughtful detail: live cross-window sync — switch the language to Chinese in one window and another open window follows immediately, no switching each one. The editor completed full bilingualization too and passed runtime verification. For a platform that wants to be used by creators worldwide, the language wall must be torn down first — and this day tore it down completely.

Devtools panels completed: Console + Network + on-disk logs

The devtools area previously had panels that were either empty or unclickable placeholders; this day completed them into real features at once. The Console panel wired up the full output streams of the game and editor — every log your game prints and every error it throws now flows here in real time. The Network panel went from a dead placeholder to the real thing, capturing the various network requests your play-tested game makes: regular requests, async requests and long-lived connections all visible. Further, the console, network and info streams aren't just shown in a panel but mirrored to local log files for later review — you needn't catch a problem live; you can replay it from the logs afterward. A tab redundant with the monitoring view was removed to avoid the confusion of showing the same thing in two places. The significance: debugging is an unavoidable part of creation, and the prerequisite for debugging is "being able to see." When a game behaves wrong, seeing the full console errors and network traffic directly in a panel turns debugging from "guessing by feel" into "checking against evidence."

UI polish: stacking, contrast, accessibility

Taking the chance of this big change, several long-standing UI issues were straightened out together. One is stacking order: previously some dialogs, dropdowns and the language selector would wrongly cover the top bar or hide beneath a dialog, and this day re-ordered their layering clearly, so what should be on top stays firmly on top. Two is form-control contrast: certain native input boxes and buttons previously showed the browser's default black text because styles weren't wired up, nearly unreadable on a dark background; this day gave them readable theme colors. Three is accessibility: prompt dialogs got the titles the standard requires, eliminating accessibility errors and letting people using assistive readers understand dialog content correctly. Each of these is small, small enough that most people won't specifically notice; but together they decide one thing — whether the interface feels "normal" everywhere. An interface with little awkwardnesses everywhere continuously and subtly drains a user's patience; smoothing them one by one buys a solid sense that "everything feels right to use."

Directional shadows fixed + declarative system scheduling

The engine fixed, at the root, a problem that had nagged for several days: directional-light shadows. While building sample games over the preceding days, there'd been no choice but the stopgap of "changing the shadow's cascade count from 4 to 1" to get shadows casting reliably — that only dodged the symptom, with the real disease in the engine. This day cured it fully: the root causes of cascaded shadows failing under certain configurations, and of misalignment at a single level, were cleared together. With the upstream stable, every downstream game's directional shadows work properly, no more symptom-only workaround. The same day, game logic gained a valuable capability: declarative system scheduling. A game is composed of many "systems" (logic modules each minding one area, like movement, collision, AI), whose run timing and order used to be arranged by hand; now they can be scheduled declaratively by condition, by label, by current state — "run this set of systems only in combat state," "schedule these systems together under one label." This makes complex game behavior logic more orderly to write and less prone to chaos. Underneath, fault isolation (turning a low-level crash into a recoverable error with automatic retry) and an offline render-frame viewer were added for smoother graphics debugging.

The engine disciplines resources: reclaim when done, don't crash when broken

The engine also put real work into "resource management" this day, exactly where a long-running program is most prone to trouble. One part is the lifecycle of GPU and audio resources: every chunk of video memory and every sound channel, when no longer referenced by anything, can be accurately identified and reclaimed in time rather than quietly piling up — this day specifically built a "release no-longer-referenced resources" mechanism and verified with a long-running stress test that it indeed holds at a stable, bounded usage level instead of ballooning. The other part is fault isolation: when a serious low-level error occurs, the engine can turn it into a properly-handleable error rather than crashing wholesale, retrying when needed. Both are under-the-hood work users don't see yet that directly decides "whether it can run stably for a long time." A game might run for several hours straight, constantly creating and destroying resources; only by making "return when done, withstand when broken" solid does long play avoid getting laggier or crashing inexplicably.

What this day means

The day's keyword is "clearing barriers." Bilingualization clears the language barrier, giving the platform, for the first time, the basic conditions to face a global audience — how far a tool goes depends first on how many people can understand and use it. Completing the devtools clears the debugging barrier, letting creators see the truth when problems arise rather than fretting at a black box. Fixing the engine shadows clears the barrier from "treating symptoms" to "treating the root," resolving at the source a recurring ailment that could only be worked around. And declarative scheduling and resource management clear the barrier of possibility for more complex, longer-running games. Tearing down these barriers one by one makes the platform simultaneously more reachable, more transparent and more reliable. A tool that genuinely wants to be widely used and trusted long-term often does exactly this plain thing: continually finding barriers, then earnestly tearing them down.