In short
- Qwen3.5-4B-3D-Coder is a 4B model that generates 3D assets as code — 221,506 downloads and 828 likes as of 25 October make it the breakout niche model of the month, and the download-to-like ratio suggests people are actually running it.
- At 4B this is laptop-class: expect a Q4 quant around 2.5–3GB, comfortable on an 8GB GPU or 16GB Mac. Three routes: Ollama (easiest), llama.cpp (best for the scripted generate-execute-export loop), or transformers from safetensors.
- A GLB sibling, ccore/Qwen3.5-4B-GLB-3D-Coder, appeared on trending on 1 November with 24,479 downloads — watch whether its direct-GLB output converges with the original's traction.
- speridlabs/idol (image-to-3D, 1,016 likes, 20,689 downloads as of 28 October) is the natural companion for organic shapes the code-based model can't handle — though the combined pipeline is our suggested workflow, not a documented one.
- We've seen no independent benchmarks for either 3D coder variant — all quality claims come from the model cards. Never blind-execute generated code; sandbox it.
What Qwen3.5-4B-3D-Coder actually is
ccore/Qwen3.5-4B-3D-Coder is a 4B text-generation model fine-tuned for one job: 3D code generation. Instead of describing a 3D object in prose, it writes the code that defines the object — you run the code, and a mesh comes out the other end.
The numbers explain why it deserves a guide. As of 25 October, it sat on Hugging Face trending with 221,506 downloads and 828 likes. That's a genuinely high download-to-like ratio — the inverse of the high-like, low-download pattern we flagged in our best-LLM-right-now roundup, where the model topping trending looked more watched than run. When downloads outnumber likes by roughly 270 to one, it suggests people are actually running this model, not just bookmarking it.
There's also a sibling: ccore/Qwen3.5-4B-GLB-3D-Coder, which appeared on trending on 1 November with 236 likes and 24,479 downloads. The name points at direct GLB output — GLB being the binary glTF format that Blender, Unity, Godot and web viewers like three.js all accept as a standard import. We've inferred that from the name and the model card's positioning rather than verified it end-to-end, so check the card before committing to that route.
Honesty first, though: as with most fast-moving community models, all quality claims come from the model cards. We've seen no independent benchmarks. The download numbers are the strongest signal available, and they say "worth trying", not "proven best".
What "3D code generation" means in practice
There are two broad ways to generate 3D locally, and it's worth being clear which one this is.
Diffusion-based 3D generation produces a mesh directly from a prompt or image — impressive, but the output is a black box. You get what you get.
Code-based generation — this model's approach — works differently. You prompt with a description, and the model emits a script (typically Python-style mesh or scene code) that, when executed, produces the geometry. The output is deterministic and editable: if the mug handle is too thick, you change a number in the code and re-run. That's the whole appeal for anyone making game assets or 3D-print candidates. You iterate on the artefact, not on dice rolls.
If you've used a general coding model like qwen2.5-coder:7b to write Python, you already know the interaction pattern — the difference here is that the fine-tune is aimed squarely at mesh and scene code, so you get usable geometry from short prompts instead of scaffolding you have to debug into shape.
The GLB variant, if it does what its name implies, skips a step: rather than emitting a script you wire up to a 3D library yourself, it's positioned to emit output that converts straight to a GLB file — drop it into Blender, Unity, Godot or a three.js viewer with no intermediate plumbing.
Why 4B matters: this is a laptop-class model. It sits in the same size band as the other 4B models we've covered this autumn — pplx-decider-flash and d3:4b — not a 40GB monster like flint. Expect a similar footprint and similar hardware demands.
The trade-off to admit up front: code-generated 3D tends toward hard-surface, low-poly geometry. A 4B text model writing mesh code will give you a credible low-poly chair; it will not give you a photoreal organic creature. For organic shapes and real-world objects, you want an image-to-3D pipeline — which is where the companion model below comes in.
Choosing your route: Ollama, llama.cpp, or raw weights
Three realistic routes, depending on what's available when you read this:
| Route | Ease of setup | What you need | Best for |
|---|---|---|---|
| Ollama | Easiest | Ollama + a GGUF (library listing or Modelfile import) | Quick testing; free OpenAI-compatible local API |
| llama.cpp | Medium | A GGUF + llama.cpp build | Scripting the generate-then-execute loop |
| transformers | Heaviest | Python + full safetensors (~8GB for 4B at BF16) | Full precision; no GGUF dependency |
One caveat, stated plainly: as of writing, the model cards are the source of truth for GGUF availability. Before picking a route, check the "Files and versions" tab on the HF page and search the community GGUF listings. Community quants for trending models often appear within days, so what's missing today may exist by the time you try.
The hardware arithmetic is friendly either way. A Q4 quant of a 4B model is roughly 2.5–3GB. That's comfortable on any 8GB+ GPU or a 16GB Mac.
Running it in Ollama
If you're new to Ollama generally, our Ollama engine guide covers the install; here's the model-specific path.
Step 1: check the library. Search the Ollama library for the model under a plausible name. If it's listed, this is the whole setup:
ollama run qwen3.5-3dcoder
Step 2 (the likely path): import a GGUF via a Modelfile. If the model isn't on the library but a GGUF exists on Hugging Face, download it and wrap it:
FROM /path/to/qwen3.5-4b-3d-coder-Q4_K_M.gguf
# Copy the chat template and parameters from the HF model card
PARAMETER temperature 0.3
SYSTEM "You generate 3D assets as executable code. Output only a fenced code block. No prose."
Then:
ollama create qwen3.5-3dcoder -f Modelfile
ollama run qwen3.5-3dcoder
The chat template matters — copy it exactly from the model card, or the model will produce mangled output.
Step 3: test it. Start with something simple and inspectable: "a low-poly coffee mug". What you want back is clean, runnable code in a fenced block — not prose describing a mug. If you get chatty output, tighten the system prompt and check the template.
Practical settings: because the output is code you'll execute, keep the temperature low — 0.2–0.4 is the sensible band for code generation — and pin the output format in the system prompt. Determinism is the feature here; you're not paying for creativity.
The honest gap: if no GGUF exists yet, Ollama can't run safetensors directly. That's a llama.cpp/transformers job, or a short wait for the community quant.
Running it with llama.cpp
Build or install llama.cpp, then serve the GGUF:
llama-server -m qwen3.5-4b-3d-coder-Q4_K_M.gguf --port 8080
That gives you an OpenAI-compatible endpoint on localhost. Ollama and llama.cpp share a ggml lineage, so single-request speeds on identical quants are usually close — the reason to go direct is control, and this model is a case where control pays off.
Why? Because the workflow is inherently scripted: prompt the model, capture the code block, execute it against your 3D library, save the mesh. A small Python script against llama-server does the whole loop. Here's the skeleton — treat it as a pattern, not something to run verbatim, because the model's exact output convention (which library it targets, what variable it defines) comes from its model card, which we haven't verified:
import re, requests
r = requests.post("http://localhost:8080/v1/chat/completions", json={
"messages": [
{"role": "system", "content": "Output only a fenced Python code block using trimesh. The code must build a mesh and call mesh.export('out.glb') itself."},
{"role": "user", "content": "a low-poly coffee mug"}
],
"temperature": 0.3,
})
text = r.json()["choices"][0]["message"]["content"]
code = re.search(r"```python\n(.*?)```", text, re.S).group(1)
# Write the extracted code to a file...
with open("gen_asset.py", "w") as f:
f.write(code)
# ...then execute it inside a container or restricted sandbox.
# Never run model-generated code in your main shell or environment.
# e.g.: docker run --rm -v "$PWD:/work" -w /work python:3.12-slim python gen_asset.py
The point is the pattern: request → extract fenced code → write to file → execute in a container → export GLB. Asking the model to do the export itself avoids assuming a particular variable name. Swap trimesh for whatever library the model card specifies, and adjust the extraction to match the card's documented output convention.
One safety line worth writing twice: never blind-execute model output. This is generated code like any other LLM output — run it in a container or a restricted sandbox, not your main shell.
The image-to-3D companion: speridlabs/idol
Here's where this guide goes beyond what's currently ranking: the other 3D model that trended in late October is speridlabs/idol — image-to-3D, with 1,016 likes and 20,689 downloads as of 28 October. It takes an image and produces a 3D asset. That's the complementary half of the workflow.
To be clear about what's documented and what isn't: we have not verified any interop between these two models, and nothing in either model card describes them working together. The pipeline below is our suggested workflow — a reasonable way to combine two trending models — not a documented integration. The key constraint is that the 3D coder is text-in/text-out: it can't consume a mesh. The handoff, in practice, is a text description of what idol produced.
The suggested pipeline:
- Photograph or sketch an object — a real-world mug, a chair, a game prop.
- idol turns it into a 3D reference or mesh — covering the organic and real-world shapes the 4B coder struggles with.
- You describe the object in text — either from your original reference or from inspecting idol's output — and prompt the 3D coder to generate it as editable code.
- Export GLB and drop it into Blender, Unity, Godot or a web viewer.
A ComfyUI-style graph suits this well: image input node → idol node → text prompt of the object → coder model node (pointed at your llama.cpp or Ollama endpoint) → code execution node → GLB output. Each stage is inspectable and re-runnable, which is the whole point of doing this locally.
Why the pairing makes sense in principle: idol covers what the coder can't (organic shapes, real-world references), and the coder gives you what diffusion output can't (deterministic, editable geometry). Together they'd cover most hobby use cases — game assets, 3D-print candidates, web viewer content.
Hardware reality check: the 4B coder is a known quantity — 2.5–3GB at Q4, comfortable on an 8GB+ GPU or 16GB Mac. idol's footprint is not something we've verified; check its model card for exact requirements before assuming both fit on one machine. We haven't run this pipeline end-to-end ourselves, and the honest expectation is that you'll spend an evening wiring it together.
What to watch, and what we'd verify first
To be clear about the state of play: we've seen no independent benchmarks for either 3D coder variant. Treat all quality claims as vendor/community-reported until third-party numbers appear. The 221k downloads say people are trying it — not that it beats the alternatives.
The GLB sibling is newer and much smaller in traction (24,479 downloads on 1 November versus the original's 221,506 on 25 October). If direct GLB output is your goal, watch whether it converges — a fast-growing GLB variant would change our route recommendation, since it removes the execute-the-script step entirely.
Things that would change this guide:
- An official Ollama library page for either model
- Official GGUFs from ccore, removing the community-quant dependency
- A ComfyUI node for either model, which would collapse the pipeline above into a single graph
Check the HF pages before following any specific step here — this space moves in days, not months.
What we'd pick: llama.cpp for the scripted pipeline if you're building the image-to-3D workflow, Ollama if you just want to poke at the model this evening. And if you want to prototype the prompt-and-extract-code loop before setting anything up, some open models are callable free within limits on Inpherio — see the free-models list — so you can build the loop in the cloud, then move it locally to the 3D coder.
More local AI coverage is on the local-ai hub.
Questions people ask
Can Ollama run Qwen3.5-4B-3D-Coder?
Yes, if a GGUF exists — either via the Ollama library (if listed) or by wrapping a Hugging Face GGUF in a Modelfile with ollama create. Ollama can't load safetensors directly.
Is there a GGUF of Qwen3.5-4B-3D-Coder?
Check the model's 'Files and versions' tab on Hugging Face and community GGUF listings — availability for fast-moving models changes within days. The model cards are the source of truth as of writing.
What's the difference between Qwen3.5-4B-3D-Coder and the GLB variant?
The original emits a script you execute to build a mesh; the GLB variant is named for direct GLB output — check its model card for exactly what it emits, as we've only inferred the format from the name.
What hardware do I need to run a 4B 3D-generation model locally?
A Q4 quant of a 4B model is roughly 2.5–3GB — comfortable on any 8GB+ GPU or a 16GB Mac, the same band as other 4B models we've covered this autumn.
Can I go from an image to a 3D model locally?
Yes — speridlabs/idol (image-to-3D, trending 28 October) produces a 3D asset from an image. Pairing it with the 3D coder is a suggested workflow, not a documented integration; the handoff between them is via text description, since the coder is text-in/text-out.
Models in this post — live on Inpherio
Have a GPU, a Mac or a spare PC?
Let it earn while you sleep.
Run open models for people who need them. You set the price and keep everything but the 15% fee.
Become a hostBuilding with AI?
Every open model, one API.
OpenAI-compatible. Priced by the people who run the hardware.
Start free See the marketplaceRead “Qwen3.5-4B-3D-Coder locally: the setup guide that doesn't exist yet” at https://inpherio.co.uk/blog/qwen3-5-4b-3d-coder-locally-the-setup-guide-that-doesn-t-exist-yet