WVY-3D-23m

A tiny language model that writes 3D art as code.

WVY, designed by Starpower.

WVY-3D is a 23.1-million-parameter transformer trained from scratch. Give it a short prompt like "a pixel car" and pick a format. It writes the code that draws it:

• three.js: JavaScript that builds and returns a THREE.Group
• SVG: a complete standalone vector image
• SDF shader: a GLSL ES 3.0 fragment shader that raymarches the object as signed distance fields

23.1M parameters · 92 MB safetensors · ~275 tokens/s on CPU · three output formats

▶ Try it in the browser

WVY-3D is the successor to WVY-Blender-5m. That model made selections: it picked tokens from a fixed scene language, and a procedural builder supplied the geometry. WVY-3D writes the geometry itself, as code, and learns to compose a style transformation with an object it has never seen in that style.

See it in motion

Every clip in the video is the model's first answer (seed 0, temperature 0.45). The code streams at the speed it was actually generated on an Apple M4 CPU, and the demo runs it exactly as written. The only change is a turntable spin on three.js objects. The prompts, seeds and the exact code for every clip are in demo_manifest.json.

The test: pairs it has never seen

The training data covers 25 objects × 6 styles × 3 formats. Five object + style pairs were held out completely: they never appear in training, in any format.

To draw a pixel car, the model has to apply the pixel transformation, learned on other objects, to the parts of a car it learned in other styles. Here is every held-out pair in every format, uncurated: seed 0, first try.

Two of the 15 fail an automated check, and they are marked. The pixel-car SVG passes the checks but only draws the wheels, a stripe and a taillight, which shows the checks don't catch everything.

Gallery

These are trained pairs across the vocabulary, one prompt each. Seed 0, first try, nothing re-rolled; we chose the prompts.

Every image is also in media/gallery/ at 640×640. The prompt, check results and full code for each one are in gallery_manifest.json.

Benchmark

All numbers come from the same checkpoint. A sample passes only if it does all of these:

• Runs: three.js executes in Node, the SDF compiles and links in WebGL2, and the SVG parses.
• Uses the style: it contains the style's signature idiom (voxel grid, flatShading, glow, edges…).
• Draws the object: its parts overlap the object's reference part list (Jaccard ≥ 0.6).
• Matches the palette: it uses the style's colours.
• Has the right plan line: its first-line comment names the object and style.

Temperature. Held-out pass rates by sampling temperature:

Loss. Teacher-forced loss on gold code is 0.055 nats/token for trained pairs and 0.141 for held-out pairs (perplexity 1.06 vs 1.15). The gap is largest for SVG and smallest for SDF.

Speed. On an Apple M4 CPU (4 threads, batch 1), decoding runs at about 275 tokens/s and the first token arrives in about 6 ms. A three.js object (~200 tokens) takes under a second; an SDF shader (~540 tokens) about 2 s. Peak memory is about 535 MB.

The full results, per pair and per check, are in benchmark.json.

Known limitations

• Fixed vocabulary. It knows 25 objects (car, truck, bus, boat, plane, rocket, frog, cat, duck, pig, fish, robot, snowman, mushroom, tree, pine, cactus, flower, house, bench, chair, table, lamp, fountain, castle) and 6 styles (smooth, pixel, low poly, clay, neon, wireframe). Other words are not reliably understood.
• Colour and size words slip in the plan line. With prompts like "a big red pixel car", the code usually applies the colour (70 / 90) and the size (45 / 45) correctly. But the first-line plan comment often names the wrong object (correct in 3 / 90). This is the main thing the next version fixes.
• Pixel cars in three.js sometimes stop before the voxel-mesh block (10 / 16 pass). This was the cause of every three.js runtime failure in the benchmark.
• SVG is the weakest format on held-out pairs. The low-poly bus SVG sometimes draws car parts (6 / 16 pass), and the neon house SVG sometimes uses off-palette colours (11 / 16).
• Neon in three.js is lit like everything else in the viewer's daylight scene, so it reads as bright colour rather than glow.
• The training data is procedural. All 200,000 training samples were generated by our own builders, so outputs share that visual language. It does not make arbitrary meshes.

What it was trained on

WVY-3D was trained from scratch on 200,000 prompt → code pairs that we generated locally. No scraped code, images or pretrained models were used.

Each sample is built from three factors: an object (a list of named parts with shapes, sizes and colours), a style (a transformation applied to those parts, such as voxelizing, faceting, glow or edges), and a format (the emitter that writes three.js, SVG or GLSL). The five held-out pairs are removed from training entirely. Prompts vary their wording ("8-bit", "voxel", "blocky" for pixel; "sedan", "auto" for car), and may add colour and size words.

Each sample starts with a plan line, e.g. // wvy-3d: car, pixel, so the model commits to what it is drawing before it writes code.

Model details

Run it locally

pip install torch safetensors huggingface_hub
hf download StarpowerTechnology/WVY-3D-23m --local-dir WVY-3D-23m
cd WVY-3D-23m
python generate.py "a pixel car"                          # three.js
python generate.py "a neon house" --format sdf            # GLSL fragment shader
python generate.py "a clay rocket" --format svg --out rocket.svg

From Python:

import wvy3d

model, tok = wvy3d.load("StarpowerTechnology/WVY-3D-23m")   # or a local folder
code = wvy3d.generate(model, tok, "a wireframe frog", "threejs", seed=0)

Running what it writes

• three.js: the code is a function body that receives THREE and returns the object.

  const obj = new Function('THREE', code)(THREE);
  scene.add(obj);
  

• SVG: save it as a .svg file and open it. It's a complete document.
• SDF: a GLSL ES 3.0 fragment shader. Draw a full-screen triangle and set uniform vec2 R (resolution in pixels) and uniform float T (time in seconds). It writes to out vec4 O.

The Space does all of this in the browser, and can also export three.js output as GLB.

Files

License

Apache-2.0.