Run CCORE's Qwen3.5-4B GLB-3D-Coder Locally for Game Assets
CCORE's open-weight 4B model turns text prompts into editable 3D GLB game assets. Here's how to run it locally with GGUF quantization.

What is CCORE’s GLB-3D-Coder and what does it actually generate?
GLB-3D-Coder is a 4-billion-parameter coding model, fine-tuned from Qwen3.5-4B, that writes complete Three.js HTML pages from a text description of a game asset. It doesn’t output a 3D file directly. It outputs working JavaScript and HTML that renders the object in a browser, complete with an Export GLB button. Click that button and you get a real .glb file you can drop into Godot or any other engine that supports the format. The model is released under Apache 2.0 by an independent developer and project called CCORE, trained on a custom dataset of nearly 4,000 tested Three.js-to-GLB examples spanning 40 asset categories.
TL;DR
- GLB-3D-Coder is a 4B model fine-tuned from Qwen3.5-4B that converts text prompts into Three.js code, which then exports to GLB files for use in game engines.
- Three weight formats are available: Q4_K_M and Q8_0 GGUF quantizations for local inference, plus the original Safetensors checkpoint (about 17.49 GB across five shards, FP32 text weights with BF16 vision weights).
- The training dataset is public too, called ThreeJS-3D-GLB-Assets, with 3,918 rendered and validated examples across 40 domains, so you can inspect exactly what shaped the model’s outputs.
- Generations run long: the model was trained on examples up to 72K tokens and averages around 20K tokens per response, so an 8K output cap will truncate results and produce broken HTML.
- Thinking mode needs to stay on with no token budget restriction; the project’s own testing didn’t validate quality with reasoning disabled or capped.
- A specific sampling recipe is recommended: temperature 0.8, top-K 40, top-P 0.95, min-P 0.0, repeat penalty 1.0, which is what was used during the project’s recorded evaluations.
- Downloads passed 20,000 with over 230 likes on Hugging Face shortly after release, and the model has already been used to build a playable browser arena game called RIFTWARD.
| Vendor | Tier | Risk | ApprovalNEW |
|---|---|---|---|
| Northwind Supply | Tier 1 | Low | Approved |
| Acme Logistics | Tier 2 | Medium | Approve |
| Helios Data | Tier 1 | High | Pending |
| Granite Freight | Tier 3 | Low | Approved |
| Pinecrest Labs | Tier 2 | Low | Approve |
How do you set this model up locally?
The practical path is a GGUF runtime like LM Studio or llama.cpp, since most people running a 4B model locally want quantized weights rather than the full Safetensors checkpoint. The setup follows a short sequence:
- Download either the Q4_K_M or Q8_0 GGUF file (or the original Safetensors checkpoint if you want full precision and have the VRAM and tooling for it).
- Load it in a runtime that supports the Qwen3.5 architecture.
- Paste in the system prompt that instructs the model to generate low-poly Godot-compatible assets as a single standalone HTML file using Three.js, with an Export GLB button and animation support when requested.
- Send a plain-English description of the asset you want.
- Save the model’s HTML output to a file, open it in a browser (it will pull Three.js from a CDN), inspect the rendered object, then click Export GLB to get your file.
If you downloaded the model before its November 5, 2026 update, the project’s documentation specifically calls out that you need to delete the old files and redownload. The GGUF filenames didn’t change between versions, which means a stale local copy can silently sit there looking current.
Which quantization should you pick: Q4_K_M or Q8_0?
Q8_0 is the format used in the project’s own recorded evaluations, so it’s the safer choice if you want outputs that match the examples shown in CCORE’s documentation and showcase gallery. It preserves more precision at the cost of a larger file and more memory and compute during inference. Q4_K_M is the more compact option, trading some precision for a smaller footprint, and it’s the more practical pick if you’re running on limited VRAM or want faster generation.
Given that this is a 4B parameter model, both quantizations are small enough to run on consumer hardware that can handle local LLM inference generally, a meaningful departure from most text-to-3D tooling that depends on cloud APIs or heavier diffusion-based pipelines. There’s also an original Safetensors release (five shards, roughly 17.49 GB, FP32 text weights plus BF16 vision weights) for anyone who wants the unconverted checkpoint, plus an optional 644 MiB BF16 vision projector file if you need image input support in a multimodal-capable GGUF runtime.
Why does output length matter so much with this model?
Because the model was trained on examples that run long, and cutting off generation early produces unusable code. CCORE’s documentation is explicit on this: training examples reached up to 72,000 tokens, and typical responses average around 20,000 tokens. An asset with detailed geometry, multiple materials, and an animation rig needs a lot of code to describe in Three.js, plus the model’s internal reasoning before it writes that code.
Setting an 8K token output limit, a common default in many local runtimes, will frequently cut the response off mid-thought or mid-HTML, leaving you with a file that won’t parse or render. The documented fix is to set the output limit to unlimited (-1) wherever the runtime supports it, and to leave thinking/reasoning mode enabled without any separate token budget for it. The project notes it hasn’t validated output quality with thinking disabled or restricted, so this isn’t just a performance suggestion, it’s closer to a requirement for getting correct results.
Is the local setup worth it compared to other text-to-3D approaches?
For a specific use case, yes: fast iteration on low-poly, stylized game assets that need to land directly in an engine like Godot as GLB files. Because the model writes code rather than directly outputting mesh data, you can inspect, tweak, and debug the Three.js source before exporting, which gives you a level of control that black-box 3D generation pipelines typically don’t offer. The project’s own side-by-side comparisons against DeepSeek V4.1 Flash (run at high reasoning effort) on prompts outside the training set show the small fine-tuned model producing coherent, prompt-matching assets like a coral-armored lighthouse keeper or a frozen goblin watch camp, despite the two-order-of-magnitude difference in general-purpose model scale.
The tradeoffs are real, though. The documentation flags that some requests need a retry or a manual code fix, and that materials, lighting, and animation can look different once imported into an actual game engine compared to the browser preview. This is a specialized, narrow-purpose model, not a general 3D content platform, and it inherits the usual caveats of small fine-tuned models: strong in its lane, inconsistent outside it.
What’s the broader project around this model?
CCORE has released the model, its training dataset (ThreeJS-3D-GLB-Assets, 3,918 examples across 40 domains), and a prompt gallery organized by asset category, from characters and weapons to vehicles and modular architecture pieces. The project also published RIFTWARD, a playable browser arena game built using assets generated by this model’s latest checkpoint, assembled with the help of an orchestration and validation harness that handled gameplay logic and UI separately from asset generation. A community member, Naoki Kishida, independently built a playable 3D RPG demo using an earlier preview version of the model, which is also linked from the project page.
The developer states the work is self-funded and released free of charge, with a stated plan to scale up toward 100,000 curated examples for training future small coding models aimed at 3D and general-purpose tool use, estimated at roughly 20 times the effort of the current release.
Frequently Asked Questions
What hardware do you need to run GLB-3D-Coder locally?
The model is a 4B parameter model available in Q4_K_M and Q8_0 GGUF quantizations, both designed to run on consumer hardware capable of general local LLM inference. Q4_K_M has a smaller memory footprint; Q8_0 needs more VRAM but matches the precision used in the project’s own evaluations.
Does the model output 3D files directly?
No. It generates a complete Three.js HTML/JavaScript page that renders the asset in a browser and includes an Export GLB button. You open the HTML, inspect the preview, and click export to produce the actual .glb file.
Why do my generations get cut off or produce broken code?
Most likely an output token limit set too low. The model averages around 20,000 tokens per response and was trained on examples up to 72,000 tokens. Set the output limit to unlimited (-1) where your runtime allows it, and keep thinking/reasoning mode enabled without a separate token cap.
Can this model generate animated assets?
Yes, if you ask for it explicitly. The system prompt instructs the model to add animation when requested and include it in the exported GLB; otherwise it defaults to a static asset. Always check the exported file to confirm the animation carried over correctly.
Is the training data available to inspect or reuse?
Yes. CCORE released the full training set, ThreeJS-3D-GLB-Assets, containing 3,918 tested and rendered examples across 40 domains with validated GLB exports, separately on Hugging Face under the same project.


