Spark-X2.6-4B-Blender

A 4B model that writes Blender 5.x Python (bpy) scripts which build clean, quad-dominant meshes: hard-surface props, furniture, products, and anatomically proportioned organic base meshes (humans, hands, quadrupeds).

Full-parameter fine-tune of XHToken/Spark-X2.6-4B-Base (all 4.1B weights, no adapters). Every training script was executed headless in Blender and kept only if it ran and produced geometry; topology was scored on the evaluated mesh.

Results

All numbers come from running the model's output in Blender 5.2.1 LTS headless, greedy decoding. run = script executed and built geometry · topo = mean topology score of those (max 1.0) · fid = fidelity to the reference answer (size, proportions, part count; failed scripts count as 0).

Held-out BlendNet rows and anatomy eval prompts are never seen in training (anatomy prompts use a different random seed). BlenderWorld is scored for execution and topology only; its rubric judge was not run.

Every stage is also compared with the base model on identical prompts: exact McNemar test on which prompts pass, shape F-score@0.05 and Chamfer distance against the reference's surface point cloud (2048 area-weighted samples, both normalised for placement and size), with 95% bootstrap intervals. A stage counts as better only if it wins on every suite at p < 0.05 without general-text perplexity rising more than 1.05× (criteria fixed before results).

Sample outputs: best and worst

Rendered straight from this model's generated scripts on held-out prompts (greedy, one attempt), ranked by the suite's metric.

BlendNet: 100/100 scripts built (failures render nothing).

Anatomy: 60/60 scripts built (failures render nothing).

3DCode: 20/50 scripts built (failures render nothing).

Spatial assemblies: 60/60 scripts built (failures render nothing).

Language-model metrics (same tokens, run vs base)

Checkpoints

main holds the best stage so far (by held-out evals) — currently the v3 weights above; mid-training checkpoints are not published to this public repo. Finished runs are backed up to the private repo hotocooo/Spark-X2.6-4B-Blender-checkpoints (v1/, warm_v4/, v5/, v3/, v6/, v6g/, v7/, v7a/, v7d/, v3d/, v3dr/, v3drr/): a local copy is deleted only after every uploaded file's sha256 matches the remote LFS object (small files: checked by size), and GGUFs are rebuilt on demand from the restored weights.

Quick start

from transformers import AutoModelForCausalLM, AutoTokenizer

repo = "hotocooo/Spark-X2.6-4B-Blender"
tok = AutoTokenizer.from_pretrained(repo, trust_remote_code=True)
model = AutoModelForCausalLM.from_pretrained(repo, trust_remote_code=True, torch_dtype="bfloat16", device_map="auto")

prompt = '### Task\nWrite a Blender 5 Python (bpy) script that builds this, with clean quad topology:\nA wooden stool with three legs and a round seat.\n\n### Script\n'
ids = tok(prompt, return_tensors="pt").to(model.device)
out = model.generate(**ids, max_new_tokens=4096, do_sample=False, top_k=0)
script = tok.decode(out[0, ids["input_ids"].shape[1]:], skip_special_tokens=True)
print(script)

Run the script in Blender: blender -b --python script.py or paste it into the Scripting workspace.

Requirements: transformers==4.57.1 (the architecture code ships with the repo and targets the 4.x API), trust_remote_code=True. It is a completion model, not a chat model: use the prompt format below.

Prompt format

### Task
Write a Blender 5 Python (bpy) script that builds this, with clean quad topology:
<describe what to build>

### Script

Stop generation at the end-of-sequence token or at ###.

Anatomy base meshes

The anatomy data is procedural: anatomically proportioned joint skeletons (human: 7.5/7.2-head canons, male/female, slim/average/athletic/heavy builds, T-pose, A-pose, relaxed; hands: three phalanges per finger, opposable thumb, curl; quadrupeds: dog, cat, horse, deer, bear, digitigrade / unguligrade / plantigrade legs) wrapped by Blender's Skin modifier and smoothed with Subdivision Surface, the standard way to block in a sculpt-ready base mesh. Left/right symmetry is exact (mirrored in the data, not with a Mirror modifier, which would weld the centre line).

Examples above (front and side, wireframe shows edge flow):

• Make a low-poly-to-subdivided base mesh of a heavy female human body, 1.62 m tall (7.2 heads), in T-pose with anatomically correct proportions.
• Create a human left hand, 19 cm long, fingers flat and open, with three phalanges per finger. Use clean all-quad topology suitable for sculpting.
• Model a deer body (1.40 m from shoulder to rump), standing, unguligrade legs and a tail as a base mesh with good edge flow and no n-gons.

Training

Data

Method

Multi-stage, every stage full-parameter and verified in Blender:

1. SFT (v1): full fine-tune on verified BlendNet + procedural anatomy, loss on script tokens only. (A long-context SFT stage on Infinigen 3DCode scripts was tried and dropped: it memorised the training factories and fell from 21/50 to 5/50 on held-out ones.)
2. Spatial grounding (v3 onward): verified procedural data so placement is computed, not guessed (a script can run and still put every part in the wrong place): part assemblies, local-to-world transforms in Blender's scale / rotate / translate order, vertex / face counts through modifiers, bounding boxes, vector geometry. Trained in SFT and rewarded in RL (assemblies by shape match, QA by the verified answer).
3. Rejection sampling (v3): sample 8 scripts per prompt, run all in Blender, keep the best only if it beats the reference's topology and matches the reference (stops "a lone cube" from winning).
4. Reinforcement learning (v4): multi-turn GRPO-family policy optimisation (DAPO token-level loss, no KL term, truncated outputs masked) with the Blender verifier as the reward. Each prompt is an agent episode: the model writes a script, sees Blender's verdict (the error, or a scene report: parts, size, quad ratio, topology), then writes a better script or submits; the whole episode is one trajectory with Blender's text masked out. v3 is taught the loop first with best-of-N repair, refine and polish examples; a short SFT on the same rows plus restored submit examples (v3 itself saw none: every submit target became a realism polish) teaches stopping before RL. Side task adapted from CodeRL+: read a script, predict its object count and size, rewarded against what Blender actually builds.
5. Selection: after each stage's held-out evals, main is replaced only if that stage beats every earlier one (currently v3); only the best model is kept.

No outputs of proprietary models (e.g. Claude, GPT, Gemini) are used as training data.

Topology score

On the evaluated mesh (modifiers applied), summed over objects: score = 1.0·quad_ratio − 0.5·ngon_ratio − 1.0·non_manifold_ratio − 0.3·pole_ratio − 1.0·degenerate_ratio − 1.0·loose_ratio, each term a ratio (quads/faces, n-gons/faces, non-manifold edges/edges, bad poles/verts, degenerate faces/faces, loose verts/verts). Bad poles are interior vertices with valence outside 3–5; 3- and 5-poles are normal in quad meshes and not penalised.

Hyperparameters

Reproducibility

Pinned: base model XHToken/Spark-X2.6-4B-Base @ e1bd659ae2b1c2263b2fc2544485976c1b516115, dataset FreedomIntelligence/BlendNet @ 11a779c7723af9bacbed371fccdc643ea20be446, transformers==4.57.1. Pipeline: Blender-verified data filter, procedural anatomy generator, full fine-tune, best-of-N, GRPO, eval, export; each stage resumes from its own checkpoints. Eval generation: base model and v1 through transformers (bf16, MPS); later stages through llama.cpp llama-server on an f16 GGUF of the same weights (identical token ids, same sampler settings), 6.5x faster. Same prompts and Blender scoring throughout.

Limitations

• Base-mesh quality, not sculpts. Anatomy is blockout level (correct proportions and clean quads, ready to sculpt); muscle definition, faces and fine detail are beyond what a 4B script-writing model produces.
• Script, not mesh. The model writes code; geometry exists only after Blender runs it. Some scripts still fail, see the run rate above.
• Topology metric is structural. It rewards quads, manifold geometry and clean poles; it does not judge aesthetics. Fidelity checks size, proportions and part count against a reference, not exact shape.
• Open-world objects are weak. Outside the trained families (BlendNet-style props, furniture and products from the generator kits, anatomy), a vague prompt such as "Make a banjo." mostly yields a stack of primitives with the right part names in the wrong places. The Objaverse column's F-score norm does not show this: it rates a two-box "bed" above a box. The judge number beside it does: a clay render is ranked against real-object renders of all ~1,124 Objaverse-LVIS categories by a SigLIP image encoder, and the true category must land in the top 20. Kit-built objects reach rank 1-20; this model's held-out outputs sit at a median rank near 200.
• English prompts, Blender 5.x API.

Safety

Generated scripts are executable Python. Run them in an isolated Blender, not one holding unsaved work. Training and evaluation statically rejected scripts importing anything beyond bmesh, bpy, collections, colorsys, dataclasses, functools, hashlib, itertools, math, mathutils, numpy, random, statistics, types, typing, warnings or touching files, network, add-ons or the app (DataSource, addon_enable, addon_install, export_scene, filepath, fromfile, genfromtxt, import_scene, libraries, load, loadtxt, memmap, open_mainfile, python_file_run, quit_blender, read_homefile, save, save_as_mainfile, save_mainfile, savetxt, savez, savez_compressed, tofile, url_open); getattr/setattr/delattr/hasattr were replaced by guarded versions that refuse those names at run time. These filters are not a sandbox.

Special thanks

Special thanks to ACOTech for providing the machine behind this. Every step ran on it, locally: data verification, every fine-tune stage, the held-out evaluations and every benchmark on this page. The machine is a Mac Studio with an Apple M4 Max, 64 GB of unified memory.

How this was made

The data pipeline, fine-tunes, evaluation, benchmarks and this page were done with Claude Code running Claude Opus 5.5, directed and reviewed by hotocooo.

Citation

@misc{spark_x2_6_4b_blender,
  title  = {Spark-X2.6-4B-Blender: full fine-tune of Spark-X2.6-4B for Blender bpy modeling},
  author = {hotocooo},
  year   = {2026},
  url    = {https://huggingface.co/hotocooo/Spark-X2.6-4B-Blender}
}
@misc{sparkx2.6,
  title  = {Spark-X2.6-4B: Advancing the Frontier of On-Device Agents for Real-World Tasks},
  author = {SparkLLM Team},
  year   = {2026}
}
@misc{du2024blenderllmtraininglargelanguage,
  title  = {BlenderLLM: Training Large Language Models for Computer-Aided Design with Self-improvement},
  author = {Yuhao Du and Shunian Chen and Wenbo Zan and Peizhao Li and Mingxuan Wang and Dingjie Song and Bo Li and Yan Hu and Benyou Wang},
  year   = {2024},
  eprint = {2412.14203},
  archivePrefix = {arXiv}
}

License: Apache-2.0, same as the base model and BlendNet. 3DCode is MIT; cite 3DCodeBench and Infinigen when using it. General-text replay uses FineWeb-Edu (ODC-By 1.0) by Hugging Face.