Tiny 4B model builds 3D assets for Godot and exports them as GLB

What this is about

Developer CCORE has released an early preview checkpoint called Qwen3.5-4B-GLB-3D-Coder on Hugging Face and introduced it on r/LocalLLaMA. It's a small coding model with 4 billion parameters, built on Qwen3.5-4B. It is explicitly not an official Qwen release. The model writes code for Three.js scenes (a JavaScript library for 3D graphics in the browser) and includes a GLB export function. GLB is a compact binary format for 3D models that game editors like Godot can import directly.

CCORE is following up on his earlier 3D coding model. After its release, many people asked whether you could use it to generate assets for your own games. So he trained a version aimed squarely at that.

How it works

You give the model a system prompt (the base instruction that comes before your actual request), then a short request as the user message. The model replies with a complete, standalone HTML file. Open it in your browser and you see the asset. An "Export GLB" button lets you download a working GLB file. If the object needs an animation, the model is supposed to build it in and include it in the GLB file; otherwise the asset stays static. You then import the GLB file into Godot or another editor.

The system prompt from the Model Card says, roughly: generate game assets for the Godot editor, which uses GLB files; build the requested item as a high-quality low-poly asset using only Three.js in a single HTML file; the page must display the asset and include an export button; add animations where needed and export them too.

Examples and settings

According to CCORE, prompts don't need to be complicated. Short English requests have worked well, such as "Create a mana potion.", "Build a goblin." or "Build a weathered frontier medic station." For more control, you can be more detailed, for example: "Create a low-poly desert merchant in a self-contained Three.js HTML scene, with a button to export the character as a GLB file for use in Godot." On the Model Card and in the Reddit video, the developer shows screenshots of assets in the browser and after import into Godot.

The sampling settings currently in use (they control how random the model's word choices are) are:

CCORE calls them a starting point and invites people to try other combinations.

Status and limits

This is the first working checkpoint. According to the developer, training is still running and should finish on the evening after the post (UTC), depending on progress. He then plans to release the full Safetensors weights and the training dataset, as he did with the predecessor model. Known limitations: some generations need another attempt or a small code fix, English prompts work better than other languages, and behavior may change with later checkpoints. All quality claims come from the developer himself; there are no independent tests or benchmarks.

What you need to try it

At 4 billion parameters, the model is small. The Q4_K_M file should take up roughly 3 to 4 GB, and Q8_0 about twice that (our own estimate; the source gives no file sizes). A graphics card with 4 to 6 GB of VRAM (video memory) is probably enough for Q4. Running on the CPU with 8 GB of RAM is also conceivable, though slower. The Model Card lists llama.cpp, Ollama, LM Studio, Jan, vLLM and other tools. For Ollama, ollama run hf.co/ccore/Qwen3.5-4B-GLB-3D-Coder:Q4_K_M is all you need. You open the generated HTML in a regular browser, and you need Godot for the import.

More context: Godot and 3D assets

The other sources show how else you can get assets into Godot. According to vr.org, Blendkit (formerly BlenderKit) released a Godot plugin in late July that gives you access to around 22,000 free models plus materials and HDRIs. The plugin is alpha, according to vr.org, doesn't run on macOS, and many .blend files import incorrectly; a GLTF option bypasses Blender. That suggests GLB/GLTF is the more robust route into Godot. Jude Janitha's Godot Pixel Renderer (MIT-licensed, according to Digital Production) converts animated GLB/GLTF files into pixel-art sequences, so it could be a follow-up step for assets made with this model. These sources don't draw any direct connection to CCORE's model.

Our take

The idea is practical: instead of generating meshes directly, a small language model writes code that assembles the object from simple shapes. That suits low-poly styles, prototypes and placeholders. Don't expect photorealistic or highly detailed results, though, and animations are probably basic. On the critical side: this is a work in progress, there are no benchmarks, the reliability claims are self-reported, and the license and Safetensors weights are still missing. Even so, it's a cheap experiment for hobbyist Godot developers, since it runs locally and for free.