CCORE GLB-3D-Coder: A Free 4B Model for Text-to-3D Game Assets
CCORE GLB-3D-Coder is a free 4B model that writes Three.js code exporting to GLB for Godot. Here's how it works and compares to DeepSeek.

What is CCORE GLB-3D-Coder?
CCORE GLB-3D-Coder is an open-weight 4B parameter coding model that turns a text description into a working 3D game asset. Instead of outputting an image, it writes a complete Three.js HTML page with a live preview and an Export GLB button, so you get a file that imports straight into Godot or any other engine that reads GLB. It’s built on Qwen/Qwen3.5-4B, released under Apache 2.0, and available as GGUF quantizations or the original Safetensors checkpoint.
TL;DR
- CCORE GLB-3D-Coder is a 4B parameter fine-tune of Qwen3.5-4B that generates self-contained Three.js HTML pages with a built-in Export GLB button, producing assets ready for Godot or other GLB-compatible engines.
- The model was trained on 3,918 tested and rendered examples across 40 asset domains, released publicly as the ccore/ThreeJS-3D-GLB-Assets dataset alongside the model weights.
- In side-by-side comparisons against DeepSeek V4.1 Flash running at high reasoning effort, the smaller CCORE model produced comparably coherent low-poly assets from the same prompts, including on requests outside its training data.
- Weights ship in Q4_K_M and Q8_0 GGUF plus original Safetensors (about 17.49 GB across five shards, FP32 text weights with BF16 vision weights), with an optional BF16 vision projector for multimodal input.
- The model needs long, uncapped output and reasoning enabled: it was trained on sequences up to 72K tokens, averages around 20K tokens per response, and an 8K token limit will routinely truncate the HTML before it’s usable.
- A showcase browser game, RIFTWARD, was built using assets generated entirely by the model, demonstrating that the exported GLB files work in a real playable pipeline without needing live inference.
- The model, its training data, and a planned 100,000-example dataset for tool-using 3D and coding models are being funded and released independently, outside any corporate lab.
How does text-to-3D generation with this model actually work?
The model doesn’t generate a mesh file directly. It writes JavaScript code that uses the Three.js library to construct geometry, materials, and (when requested) animation, then renders that scene in a browser and exposes an Export GLB button. Clicking that button triggers a GLB export from the live Three.js scene, which you can then drop into Godot or another engine.
This code-first approach matters because it’s inspectable. You can open the generated HTML, see exactly how the blacksmith’s apron or the goblin camp’s tents are constructed as geometry and material calls, and tweak the code directly if something looks off before you ever export. That’s a meaningfully different workflow from diffusion-based mesh generators, which hand you a finished (and often messy) mesh with little room to reason about how it was built.
The system prompt behind the model is specific: produce a good-quality low-poly asset using only Three.js in one standalone HTML file, include the Export GLB button, and bake in animation when requested so it survives the export. Low-poly is a deliberate constraint, aimed squarely at game-ready assets rather than photorealistic renders.
How does it compare to DeepSeek V4.1 Flash?
The model’s release materials include direct comparisons against DeepSeek V4.1 Flash (the 1017 build, run at high reasoning effort) on identical prompts, ranging from short one-liners like “Create a coral-armored lighthouse keeper” to detailed, multi-paragraph briefs specifying materials, cable routing, and mechanical plausibility for things like a magnetic-rail rescue engineer or a bioluminescent cave tram station.
The notable part isn’t that a 4B specialist model “beats” a much larger general-purpose model on every axis. It’s that a small, narrowly trained model holds its own on a task DeepSeek wasn’t specifically fine-tuned for. Both models were tested on prompts outside CCORE’s training set, which is a reasonable way to check generalization rather than memorization. For teams evaluating whether a lightweight local model can replace calls to a larger hosted one for this specific job, that parity is the headline, not raw benchmark superiority.
What’s in the training dataset?
The model was trained on ccore/ThreeJS-3D-GLB-Assets, a dataset of 3,918 examples spanning 40 domains: characters and NPCs, enemies and bosses, weapons and armor, vehicles (ground, air, and water), industrial machinery, lab equipment, farming and homestead props, traps and hazards, festival scenery, underwater structures, and puzzle elements, among others. Each example was tested and rendered, with validated GLB exports, meaning the training data wasn’t just text-code pairs but code that was confirmed to actually produce a working 3D export.
That dataset has been released publicly alongside the model, which is relatively unusual. Most fine-tuned coding models ship as weights only; here the full training corpus is available for inspection or reuse.
What hardware and settings does it need to run well?

Remy.
The model is small enough to run locally: Q4_K_M and Q8_0 GGUF quantizations are available for llama.cpp-style runtimes, and the original Safetensors checkpoint (roughly 17.49 GB across five shards, FP32 text weights plus BF16 vision weights) is available for those who want the unquantized model.
The release notes are unusually explicit about sampling and output settings, because getting them wrong breaks the model’s usefulness. Recommended sampling is temperature 0.8, top K 40, top P 0.95, min P 0.0, and repeat penalty 1.0. More importantly, output length needs to be effectively unlimited (-1 where the runtime supports it) and reasoning/thinking needs to stay enabled with no token budget cap. The model was trained on completions running up to 72K tokens and averages around 20K tokens per response. An 8K output cap, common in many default chat UI configurations, will cut the generation off mid-thought or mid-HTML, leaving a broken or incomplete file. There’s no validated fallback for disabling or truncating the thinking phase.
Is it actually good enough to use for real game projects?
The clearest evidence offered is practical rather than benchmark-based: a playable browser arena game called RIFTWARD was built using character, terrain, architecture, and environment assets generated by the model, assembled and refined with the help of an orchestration layer that also handled gameplay logic, UI, and testing. The finished game runs in-browser off the exported GLB files with no live model inference required to play, which is a reasonable proof that the pipeline from prompt to code to GLB to game engine actually holds up end to end rather than just looking good in a preview pane.
A separate community project, a playable 3D RPG demo built by an outside developer using an earlier preview version of the model, adds a second independent data point that the outputs are usable beyond the project’s own demos.
That said, the model’s own documentation is upfront about limitations: some requests need a retry or a manual code fix, and materials, lighting, or animation can look different once imported into an actual editor compared to the browser preview. Treat outputs as a strong starting point that needs inspection, not a guaranteed one-shot asset pipeline.
Frequently Asked Questions
What engines can use the exported GLB files?
Any engine or tool that imports the GLB format works, since GLB is a standard 3D interchange format. The model’s system prompt and documentation specifically target Godot, but the files aren’t locked to it.
Do I need an internet connection or API key to run it?
No. It’s an open-weight model you can run locally through a GGUF-compatible runtime, and the generated HTML pages load Three.js from a CDN but don’t require a live connection to the model itself once the code is generated and saved.
Why does it need such a high output token limit?
The model was trained on long completions, up to 72K tokens in some cases, because generating a full scene often requires extended reasoning plus a lengthy HTML/JavaScript file. Capping output at a typical 8K limit frequently cuts the response off before the code or export logic is complete.
Can the model generate animated assets?
Yes, if you explicitly request animation in the prompt. The system prompt instructs the model to add animation when asked and bake it into the exported GLB; otherwise it defaults to a static asset.
Is the training dataset usable for other projects?
Yes. The ccore/ThreeJS-3D-GLB-Assets dataset of 3,918 tested examples across 40 domains was released publicly alongside the model weights, so it can be inspected, reused, or built upon independently of the model itself.