Starforger 星铸者

days

516

coding sessions

100k+

lines of code

330+

3D models

700+

textures

Gameplay

One minute in the tower

Recorded on the current build — now fully playable in English and Chinese, with bilingual UI, dialogue, and workshop text.

Gallery

Painterly 3D, straight from the build

Real in-game captures — no staged renders. The tower gate, the hub fortress, valley combat, and the shopkeeper you meet between runs.

The process

Every asset on this page was authored by the model

Not just the code — the concept paintings, the Blender scenes, the baked maps, the shaders, and the validation captures below are all GPT-6 Astra output. What follows are the working artifacts themselves.

01Brief & taste

Design docs, references, and art direction. The human decides what "good" means; the model never sees a vague prompt twice — every asset ships with an explicit acceptance bar.

02Concept paintings

Scene keyframes, character turnarounds, and per-asset design sheets are generated first and iterated until the silhouette, palette, and mood read correctly.

03Part-built assets

Nothing is generated whole. Models are assembled in Blender by agent-written Python — procedural bmesh, generated textures, LODs — then exported to Godot.

04In-engine proof

Every asset lands in the real scene and is re-captured in-engine — same camera, same lighting, multiple angles — before it is called done.

Astra-painted concept for the title scene

Character concept turnaround painted by Astra

Combat room style frame with mobile UI mockup

Concept paintings by GPT-6 Astra — the title keyframe, the constructor's turnaround sheet, the combat-room style frame, and a per-asset design sheet.

Design samples

Six assets, six different problems

A closer look at how individual things were designed — these are Blender multi-view renders and in-engine captures of the actual production assets.

Golden grass clump — Blender multi-view render

Stylized grass

Concept sheet → generated clump → live terrain tint

The clump is built, not painted: separate leaves, stems, and seed-head meshes in two LODs, grown from a shared root disc by script until the silhouette matched the design sheet. In engine it samples the terrain color beneath it, so the same clump reads differently on soil vs. rock, and a vertex wind shader carries the breeze. Scatter zones keep paths and outcrops clear.

Weathered rocks

Pure procedural bmesh — no sculpting

Each boulder starts as a cube and is clipped by eight rotated bisect planes into weathered facets; a ninth cut flattens the base, a bevel pass erodes every edge, and three boulders of decreasing size cluster into one set. A warm sandstone ramp finishes them — the whole generator is about forty lines of bmesh, and it produces a family of three variants.

Stylized trees

Bare-trunk silhouettes first, foliage second

Design starts with the trunk: five growth silhouettes (wide / leaning / tall / low / sapling) are tuned until each reads from across the valley. Foliage is card clusters wrapped in spherical ILM normals, so the canopy shades like a solid mass instead of a stack of planes. Bark uses generated albedo, ILM, and normal maps under a custom foliage shader.

Shrubs

Same recipe, smaller scale

Bushes reuse the tree recipe at a smaller scale: one wood core wrapped in foliage clusters, in low-spread and high-crown variants. Same shader, same spherical normals — so trees, shrubs, and undergrowth read as one ecology rather than three unrelated assets.

Stylized sky

A shader system, not a texture

A three-stop gradient dome (zenith / mid / horizon) carries a sun-side airlight. Clouds are ellipsoid groups seeded per world-cell, densitied by a baked 128³ Voronoi-billow × fBm texture, and lit by Beer–Lambert self-shadowing so cores stay warm and undersides cool. Far clouds render through a panorama cache, near clouds through a per-pixel volumetric pass — one density field, two renderers.

Ancient Root boss — high-poly white model

Monsters

Part-built, never one-shot

The Ancient Root boss is 828 scripted bark-plate pieces assembled around a hollow chest core — rib cage, fractured chest plates, shoulder tendons — while the little mosskin was generated as a part, then welded, rigged, and animated by agent-written tools. High-poly → retopo → baked maps → rig → clips, with a multi-view render gate at every stage.

The game

Built for runs that feel different

Endless tower, open worlds

Every floor is a large hand-painted open world with new terrain each run — not a single arena. Bosses every 10 floors; landmark fights at 50 and 100.

Forge your build

Collect rule affixes and inscribe them onto your weapon. One affix can split a single cast into a three-way volley — conditions and effects compose.

Real-time action

You dodge, aim, and cast. Wind-up telegraphs, interrupts, and light death penalties that push experimentation over punishment.

PC & mobile

Keyboard/mouse on desktop, twin-stick touch layout with aim assist on Android and iOS — designed for both from day one. Ships in English and Chinese.

The build

One developer. Ten days. 516 sessions.

Starforger is an experiment in what a single developer can ship when the code is written by a frontier model. I didn't write the game. I directed it: over 10 days I ran 516 coding sessions — 458 of them driving GPT-6 Astra (via OpenAI Codex), the rest on earlier models. Astra wrote roughly 55k lines of GDScript for the game itself and 47k lines of Python driving a Blender asset pipeline — characters are generated part-by-part, rigged, and animated by agent-written scripts before landing in Godot.

The screenshots above are the honest version of that claim: the concept paintings, the Blender scenes, the generated texture maps, and the validation captures were produced by the same pipeline, in the same sessions, as the code.

My job was taste and direction: design docs, art direction (the painterly style took 14 concept iterations), playtesting, and rejecting bad output fast. Astra handled the how; I owned the what and the why.

It is not a toy demo — it's a hub, tower floors, real-time combat with an affix system, NPCs, a training ground, and an Android build. It's also honest about being early.

— GrinZero

Status

Early prototype, openly

Playable today: hub, tower entry, real-time combat, affix splitting, NPC shop, training range, Android debug build — in English and Chinese.
Not yet: full roguelike run loop, signed releases, mobile performance tuning.
Next: keep building with Astra — complete the run loop, then Steam/itch.io demos.