sand3d is a Python library for 3D objects written as short programs LLMs can read and edit, not as thousand-line Blender scripts. Sandflow-ai/sand3d on GitHub had more than 2,150 stars when explainx.ai checked on November 19, 2026, after roughly two weeks of public development since November 3, 2026.
The project sits at the intersection of physical AI datasets, robotics code generation, and agent tool design: if your agent must emit geometry, you need an API that survives context limits.
What problem sand3d solves
Frontier models can describe shapes in natural language, but executable 3D usually collapses into bpy or CadQuery snippets that burn context on coordinates and booleans. Sandflow's pitch is named, deterministic programs: every part, edge, face, and joint has a label; the same source rebuilds the same mesh bit-for-bit.
The README lists four measurable claims:
| Claim | What it means for builders |
|---|---|
| 2–6× fewer tokens per part | Median comparison versus Blender Python, CadQuery, FeatureScript (vendor chart) |
| ~3,600-token API surface | docs/api.md fits beside system instructions |
| Named geometry | No hand-computed vertex lists in prompts |
| Deterministic builds | Same program yields identical meshes for eval replay |
Those numbers come from Sandflow's documentation, not independent labs. They are still useful design targets when you pick a 3D tool for agents.
How a sand3d program is structured
sand3d exposes one flat namespace: import sand3d as s3d. Families include profiles (rect, slot, text), solids (extrude, loft, sweep), edits (hole, fillet, shell), joints, and assembly.
Example: bracket in millimetres
The README's starter bracket uses extrude, patterned holes, and fillet:
import sand3d as s3d
def bracket(w=80, d=40, t=6, hole_d=6.6, pitch=50):
plate = s3d.extrude("plate", s3d.rect(w, d, r=4), t)
s3d.hole(plate, hole_d, on=s3d.grid(2, 1, pitch, 0))
s3d.fillet(plate, 1, edges="top")
return plate
s3d.export(bracket(), "bracket.glb")
Millimetres are default. One export call picks format from the extension.
Example: washing machine with joints
Sandflow's flagship demo models a front-loading washer: cabinet, drum, door, drawer, dial, plus four joints (hinge, continuous spin, prismatic slide, continuous dial). The README shows roughly 38 lines for the full assembly—small enough for a single model completion with room for critique loops.
sand3d washing machine assembly with named joints for LLM procedural 3D modeling
Image: Sandflow
Joint semantics map cleanly to simulators:
- Revolute door hinge with numeric range
- Continuous drum rotation
- Prismatic drawer travel on an axis
That is the difference between pretty meshes and things Isaac or MuJoCo can load, a gap teams hit when moving from Cosmos synthetic data to deployable URDF.
Token efficiency: what Sandflow measures
Token count chart comparing sand3d to Blender Python for LLM 3D code
Image: Sandflow
The README chart plots median tokens per part across comparable objects. Sandflow argues low-rank-style coordinate math in other APIs forces models to spend tokens on arithmetic instead of structure.
For agent builders, the actionable test is simpler: count tokens for your part catalog under sand3d versus bpy on ten representative brackets, enclosures, or gripper fingers. If you run replica-skill-style app cloning, geometry is often the longest hidden cost.
Export matrix: where files go
s3d.export(model, path) routes by extension:
| Format | Carries | Typical downstream |
|---|---|---|
| GLB | Meshes, materials, joint extras at current pose | Web viewers, game engines |
| URDF | Links, joint limits at rest; OBJ meshes alongside | ROS 2, PyBullet, MuJoCo, Isaac |
| USDA / USDC / USDZ | OpenUSD scene graph | Omniverse, Isaac Sim |
| IFC4 | BIM assemblies (current pose; joint metadata omitted) | Revit via IFC link, Tekla |
| OBJ / STL | Meshes only | Slicers, generic DCC tools |
Sandflow notes Revit .rvt is not writable by third-party libraries; IFC is the interchange path. IFC GlobalIds can shift when geometry edits—do not use them as stable part IDs across exports.
Giving sand3d to your coding agent
Sandflow ships llms.txt pointing at docs/api.md for the full vocabulary. For multi-part objects, docs/guidelines.md lists eight assembly rules: plan first, then parts, then joints.
That mirrors how MCP servers document tool schemas: keep the contract in-repo so Claude Code, Cursor, or Codex can loop on export failures without guessing bpy internals.
Recommended workflow:
- Pin Python 3.13 + bpy 5.2 in your devcontainer or VM.
- Paste api.md into system context once per session.
- Ask the agent for named parts and joint declarations before mesh detail.
- Run
s3d.exportto GLB for visual QA; URDF when sim semantics matter. - Store programs in git—the source of truth—not binary meshes alone.
Hugging Face datasets
Sandflow published five datasets under CC BY 4.0, each rebuilding external corpora as sand3d programs:
- sand3d-objaverse — everyday objects from Objaverse
- sand3d-cad — mechanical parts from public CAD
- sand3d-articraft — articulated objects with declared joints
- sand3d-simready — NVIDIA SimReady assets
- sand3d-automate — AutoMate mechanical assemblies
An explorer on Sandflow's site browses examples. For fine-tuning, pair programs with serverless SFT stacks once you define grading rubrics on exported meshes.
Install constraints builders hit early
The README is explicit about bpy wheels:
- Python 3.12 is unsupported (no bpy wheel).
- Intel Macs from bpy 5.2 onward should stay on Python 3.11.
- CI runs against bpy 5.2 on Python 3.13.
If your agent sandbox is Node-only or Alpine musl, you will need a Linux glibc VM with Blender's Python module—similar friction to AnyPS5 native builds or GPU harness containers.
How sand3d fits explainx.ai's agent stack
sand3d does not replace LeRobot datasets on Lance or NVIDIA Cosmos factories. It is a authoring layer when the model must write geometry instead of retrieving meshes.
Teams building Snapchat-style AR or sim-ready props might chain:
- sand3d program from the agent
- GLB preview for humans
- URDF or USD for sim validation
- Promotion into a Lance table for training rows
Verb surface: what the API actually exposes
Sandflow deliberately avoids category magic like chair() or table(). Everything is built from profiles, solids, edits, frames, joints, and assembly verbs on the flat s3d namespace.
The README counts roughly:
| Family | Examples | Count listed |
|---|---|---|
| Profiles | rect, slot, text, offset | 16 |
| Solids and paths | extrude, loft, sweep, torus | 15 |
| Edits | hole, pocket, fillet, shell | 15 |
| Articulation | joint, pose, seat | core trio |
| Assembly | group, export, fingerprint | 8 |
Materials and gears sit beside those families. The design goal is that an agent composes primitives rather than calling opaque generators—similar philosophically to MIT Isola's agent loops where structure beats hidden helpers.
Testing and determinism in CI
Because bpy ties sand3d to Blender's Python module, Sandflow runs CI on bpy 5.2 with Python 3.13. Deterministic rebuilds matter when you:
- Store programs in git and diff them in code review.
- Replay agent trajectories in eval harnesses.
- Compare mesh fingerprints with
s3d.fingerprintstyle utilities documented in the README.
If your organization already runs Spaceship IDE on Cerebras for tight feedback loops, sand3d pairs well: short programs mean faster critique cycles before you export heavy GLB assets.
Who Sandflow is
The repository credits Thibault Neveu and Andrée Loy in CITATION.cff, with the public site at sandflow.ai. The project is young; treat release tags and CHANGELOG.md as your stability signal rather than a decade of semver history.
Limits and honesty
- Category verbs are intentionally absent—no
chair()helper; categories are programs. - Vendor token benchmarks need your own rerun on production parts.
- IFC and USD dependencies pull in heavyweight tooling on CI runners.
- The repo is young (late 2026); breaking changes may land despite CHANGELOG.md.
FAQ alignment with search intent
People who land on this page often ask whether sand3d replaces Blender. It does not: it generates bpy work through a constrained vocabulary. Others ask about robotics: prioritize URDF exports and joint tests in PyBullet before trusting decorative GLB.
Security and supply-chain notes
sand3d executes native bpy code. Treat agent-generated programs like any other arbitrary Python in your sandbox:
- Run inside disposable VMs with no outbound mail or secret mounts.
- Pin bpy versions and hash lockfiles in CI.
- Scan exports before loading GLB in production viewers—mesh bombs are rare but cheap to guard against.
That posture matches how teams already isolate Codex sandboxes and Microsoft agent frameworks after typosquatting incidents.
When not to pick sand3d
Skip sand3d when you only need single-mesh props with no joints: a glTF from an artist may ship faster. Skip it when your runtime cannot install bpy (many serverless functions). Skip it when you need NURBS CAD exactness for machining—FeatureScript or native STEP workflows still win on tolerance stacks.
sand3d shines when an LLM must author and revise articulated assets repeatedly—robot cells, appliance demos, warehouse props—without ballooning token use. Start with the README bracket example, export one GLB, and only then scale to multi-joint assemblies your sim team can load. Sandflow's explorer and Hugging Face collection pages are the fastest way to sanity-check joint naming before you automate generation.
A practical evaluation plan
Before you adopt sand3d in a team workflow, run a small, honest bake-off. Pick ten parts your agents already generate today: a bracket, an enclosure, a gripper finger, a hinge, a shelf unit. Write each one twice, once in your current bpy or CadQuery style and once in sand3d, using the same model and the same prompt template.
Then measure four things:
- Prompt and completion tokens per part, including retries after export errors.
- First-pass success rate: how often the program exports without a traceback.
- Edit cost: how many tokens a follow-up change such as "make the holes 8 mm" needs.
- Sim load rate: whether the URDF opens in your simulator with the joint limits you intended.
Named parts help most in the edit step. A model can say "fillet the top edges of the plate" without recomputing coordinates, so revisions stay small and diffs stay readable in code review. If your numbers do not show a gain on your own catalog, the vendor chart does not matter for you. If they do, you have a concrete case for moving your asset pipeline to programs stored in git.
Related reading
- Rust incremental agent rewrites with MCP parity
- ForceHarness for frozen frontier models in robotics
- NVIDIA Cosmos two-prompt physical AI datasets
- Replica Skill for app reconstruction pipelines
- What is MCP?
- SoduWork multi-harness agent hub
Star counts and dataset names follow the Sandflow GitHub README as of November 19, 2026.
