Qwen3.5-4B-GLB-3D-Coder: A Small Model That Builds Game Assets

What is Qwen3.5-4B-GLB-3D-Coder?

Qwen3.5-4B-GLB-3D-Coder is a 4-billion-parameter coding model fine-tuned to write standalone Three.js HTML/JavaScript scenes that export directly to GLB files. The GLB output is meant to drop into game engines like Godot, which makes the model a text-to-3D-asset tool rather than a general chatbot. It’s an independent preview release from a developer going by CCORE, built on top of Qwen/Qwen3.5-4B, and is not an official Alibaba/Qwen product.

TL;DR

Qwen3.5-4B-GLB-3D-Coder generates a complete, self-contained HTML file with embedded Three.js code that renders a 3D asset and includes a working “Export GLB” button.
The model was trained across 25 distinct game-asset domains, spanning characters, enemies, bosses, weapons, vehicles, modular architecture, traps, and even underwater structures.
It ships as GGUF quantizations (Q4_K_M and Q8_0), small enough to run locally through tools like LM Studio, with an optional BF16 vision projector for image-reference prompts.
A community member (Naoki Kishida) already built a playable 3D RPG demo using assets generated entirely by this model, showing the GLB output works in real game pipelines.
The developer recommends specific sampling settings (temperature 0.8, top-k 40, top-p 0.95) and a fixed system prompt that frames every request as a Godot-ready asset.
The project is fully open, with GGUF weights, a planned Safetensors release, and a training dataset the creator intends to publish alongside future checkpoints.
A much larger follow-up is planned: a 100,000-example dataset with context lengths from 8K to 128K tokens, roughly 15 times the scale of the current training run.

Let every team build.
Without shadow IT.

How does Qwen3.5-4B-GLB-3D-Coder actually generate a 3D asset?

The workflow is text in, playable GLB out. A user sends a short English prompt describing an object, like “Create a blue goblin brute” or “Build a jungle siege platform.” The model responds with a complete HTML file containing Three.js code that renders a low-poly version of that asset in the browser. That HTML file includes a button labeled “Export GLB.” Clicking it triggers a download of a working GLB file, the format Godot and most other modern game engines use for 3D models.

If the requested object needs motion (a gate that opens, a creature that walks), the system prompt instructs the model to add the animation directly into the exported GLB rather than leaving it static. According to the model card, most generations work on the first try, particularly for English prompts, though some outputs still need a retry or a manual code tweak.

This matters because it collapses a multi-step pipeline (modeling, rigging, exporting, format conversion) into a single prompt-and-click action. The tradeoff is scope: the model is built for low-poly, game-ready assets, not photorealistic or production-film-grade 3D.

What game-asset domains does it cover?

The model card lists 25 categories it was explicitly trained on, each with its own style of prompt. These include:

Characters and NPCs (a village blacksmith in a blue apron)
Enemies and bosses (a swamp goblin scout, a stone golem boss with glowing crystals)
Companions and creatures (a tiny fox companion wearing a scarf)
Weapons, armor, and pickups (an iron sword, a mana potion in a hexagonal bottle)
Props, furniture, and modular architecture (a workbench, a dungeon doorway module)
Vehicles across ground, air, and water (a courier motorcycle, a cargo airship, a fishing skiff)
Industrial, lab, and urban assets (mining conveyors, analysis stations, bus stops)
Farming, cuisine, and market scenes (harvest carts, bakery counters)
Traps, puzzles, and battlefield scenery (spiked floor traps, rune consoles, command posts)
Festivals, museums, and underwater structures (festival booths, artifact cases, coral domes)

That breadth is the point of the release. Rather than specializing narrowly in, say, fantasy characters, the training data was built to generalize across the kinds of assets a solo developer or small studio would need to populate an entire game world, not just one character roster.

Is the output good enough for real game projects?

The clearest evidence is the community showcase baked into the model card itself. A developer named Naoki Kishida built a playable 3D RPG demo using assets generated by this model, posted publicly as a web demo. That’s a meaningful signal: someone took the raw GLB exports, imported them into a working game, and shipped something playable, rather than just generating pretty screenshots.

Every team builds with AI.
Nothing gets lost.

The model card also shows direct examples of exported assets re-imported into the Godot editor, confirming the GLB files aren’t just visually correct in a browser preview but actually function once brought into a real engine. Example prompts used for these screenshots, like “Build a jungle siege platform” or “Make a reinforced mountain command post,” were explicitly excluded from the training data, which is a reasonable way to spot-check whether the model generalizes beyond memorized examples rather than just regurgitating training prompts.

That said, this is a preview release. The creator has already flagged plans to double the training dataset and retrain, citing better generalization in an earlier, related model (CCORE’s previous Qwen3.5-4B-3D-Coder) as the motivation. Expect output quality to keep shifting between checkpoints.

How do you run it locally?

The model is distributed as GGUF files, the quantized format used by local inference tools like LM Studio and llama.cpp. Two sizes are available: Q8_0 (higher precision, larger file) and Q4_K_M (smaller, more aggressively quantized). Both fit comfortably on consumer hardware capable of running other 4B-class models.

To use it, you load the GGUF into an LM Studio-style app, set the system prompt provided on the model card (which instructs the model to produce Godot-compatible GLB assets using only Three.js in a single HTML file), and send a short asset description. Recommended sampling settings are temperature 0.8, top-k 40, top-p 0.95, and min-p 0.0, though the creator notes these are starting points, not hard requirements.

There’s also an optional BF16 vision projector (about 644 MiB), the same unmodified Qwen3.5-4B vision encoder used in the base model, which lets you feed in image references if your runtime supports Qwen3.5 multimodal GGUF. It’s unnecessary for plain text prompting.

One operational note worth flagging: the GGUF checkpoints have already been updated once since the initial release (a November 2 update that the creator says noticeably improved visual quality), so anyone who downloaded the files earlier should re-download rather than assume they have the latest weights.

What’s next for the project?

The current release is explicitly a preview. The creator describes the existing training set as focused on “simple prompts,” designed to make asset generation accessible to non-technical users, and says the dataset has since been expanded to handle more detailed and customized requests across more domains.

The stated roadmap includes releasing the full dataset and the complete Safetensors weights (not just quantized GGUF files), mirroring what was done with the earlier 3D-Coder model. Beyond that, the creator is planning a considerably larger training run: around 100,000 examples with context lengths from 8K up to 128K tokens, roughly 15 times the scale of the dataset behind this current model. The eventual goal is twofold: first, reliable one-shot generation (getting a usable asset on the first prompt, consistently), and second, a version built to run inside an agent harness, where the model could generate an asset, test it, and refine it automatically as part of a larger workflow rather than requiring a human to retry prompts manually.

Frequently Asked Questions

What file format does Qwen3.5-4B-GLB-3D-Coder output?

It generates a standalone HTML file containing Three.js code, which includes an Export GLB button. Clicking that button downloads a GLB file, the 3D format used by Godot and most modern game engines.

Do I need a powerful GPU to run this model?

AI app building, made for the enterprise.

No. It’s a 4B-parameter model distributed in GGUF format (Q4_K_M and Q8_0 quantizations), designed to run on consumer hardware through tools like LM Studio, similar to other small local language models.

Is this an official Qwen or Alibaba release?

No. It’s an independent preview built by a developer under the name CCORE, using Qwen/Qwen3.5-4B as the base model. The model card is explicit that it is not an official Qwen release.

Can the model generate animated assets?

Yes. The system prompt instructs the model to add animation when a request calls for it (for example, a gate that opens) and to bake that animation into the exported GLB file. Static objects are generated without animation unless requested.

Will the training dataset be released publicly?

The creator has stated plans to release the full dataset and complete Safetensors weights once the expanded training run finishes, following the same approach used for an earlier related model.