The project goes open source + the desktop app stops crash-looping

From "for ourselves" to "for everyone"

This day is a special node in a project's life: for the first time it handed itself, completely and presentably, to the public. Open-sourcing isn't just the act of "making the code public" — it means a whole set of preparation aimed at strangers: why should others understand what you're doing? why trust that it runs? why be willing to install and modify it themselves? Everything done this day answers these questions: writing bilingual docs for each module making clear "what it is, how it collaborates, how to get started," putting open-source licenses in place so others can legally use and modify it, ensuring what's downloaded actually runs out of the box rather than missing pieces, clearing the roadblock of the desktop app crashing on launch, and making the website's examples show at a glance "what this thing can build." For an internal project going open source, the hardest part is never publishing the code itself but re-polishing what "only insiders understand" into something "anyone can pick up." That is exactly what this day did.

Open source: full bilingual docs + bring your own agent subscription

This day finished, in one pass, the public-facing polish for going open source. The core item: rich, illustrated bilingual (Chinese/English) docs across every core module and the overall super-project, all in one consistent three-part structure: part one on "why it's different" (what makes this platform special), part two on "a seven-step human-AI collaboration loop" (how human and AI turn an idea into a game step by step), part three a "map of the modules" (what parts the project comprises and what each handles). This consistent structure lets any stranger, whichever module they open first, quickly grasp it with the same mental model. The command-line side added a dedicated "bring your own agent subscription" section: you needn't be locked to one provider but can drive the whole platform with your own existing coding-agent subscription or API — choosing any of four mainstream options. Each sub-module also got its open-source license in place, so others can confidently use, modify and redistribute under clear terms. For a project wanting to be understood by a community and extended by developers, this set of docs and licenses is the first calling card it hands the world.

The desktop app stops crashing at startup

An open-source release must let people "download and run," and the packaged desktop app at the time stumbled exactly there: it crash-looped on launch, the backend repeatedly reporting a missing core runtime module. The root cause was that the module and its dependencies were left out of the package, so the offline runtime naturally couldn't find them. This day's fix bundled the entire needed runtime dependency closure fully into the desktop package, ensuring everything is present even offline and it starts properly. Two related pitfalls were solved alongside: the desktop package switched to single-game bundling, sidestepping the old resource-identifier collision when multiple games coexist; and it now tolerates the occasional "file just vanished" hiccup while copying many files during the build — a transient flicker that previously aborted the whole build under strict error checking. After the fix, the desktop app launches and enters reliably instead of dying on startup. The significance lands right at the crux of the open-source release: however good a project, if people can't even open it after downloading, nothing else matters.

The examples gallery: browse the list and run a demo side by side

Accompanying the open-sourcing, the website's examples gallery was rebuilt into a "browse-and-run" split layout. The left side lists all examples with category filtering; the right side is a live preview frame that runs whichever example you click — no download, no leaving the page, click and see. It supports deep links too: share an example's URL and the other person lands straight on that one, handy for sharing and referencing. A plugin info generator was also built, automatically capturing each plugin's metadata into structured data, so gallery cards are no longer static, lifeless images but open a detail dialog on click. For a just-open-sourced project wanting people to quickly form an impression of "what this thing can actually do," a click-and-play example gallery beats a thousand words of description — seeing a demo run with your own eyes is far more convincing than reading a paragraph.

Engine: asset-first startup + a shadow toggle + a skinned-animation fix

The engine had a big day too, advancing several things. One: an "asset-first" startup landed, with all six sample games migrated over — a game no longer relies on opening code to build the scene piece by piece but instantiates directly from a structured asset (scene description), cleaner and friendlier for a visual editor to read and write. Two: shadow control was simplified — where a directional light previously needed a separate "shadow" component to cast shadows, it's now folded into a toggle the directional light carries, turned on when you need casting; one fewer concept, more intuitive to use. Three: a real orientation bug in skinned animation was fixed — rotation data had been wrongly treated as another representation, so animated models imported from professional tools oriented wrong; fixed, the orientation is finally correct. Tilemaps also gained "object-layer" rendering (atop the cell grid, each cell can place an independent object with orientation, flip and pivot), making 2D levels more flexible; and asset registration and the renderer's health-recovery after accidents were hardened. Some improvements aim for cleaner architecture, some fix errors, some extend capability, but all make the engine's foundation more solid — right at the moment of open-sourcing, when it's about to be scrutinized and used by more people.

What this day means

This day's weight lies in the word "outward." Before it, all the platform's progress faced inward, toward itself; from this day, it placed itself, completely, before the public for the first time — anyone can download, read, run, modify and contribute. Open-sourcing is the turning point where a project goes from "a few people's work" to "a public thing," putting it into a larger context jointly scrutinized and joined by developers worldwide. Worth noting: nearly all the day's open-sourcing effort was "considerate of others": writing clear docs so strangers understand; putting licenses in place so others use it with confidence; fixing the desktop crash and ensuring one-click running so first-time visitors aren't bounced; building the example gallery so people see its possibilities at a glance. A project willing to spend a whole day just to make itself "friendlier to others" shows, by that alone, that it's ready to step into a wider world. From this day, this AI game-making platform no longer belongs only to those who build it.