# sand3d: Python 3D Modeling Built for LLMs, Not Blender Scripts

> Source: <https://explainx.ai/blog/sand3d-sandflow-3d-modeling-python-llms-november-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-11-19 00:00:00+00:00

**Key takeaway:** sand3d's named, deterministic Python programs claim 2–6× fewer tokens per part than Blender Python, CadQuery and FeatureScript, with a ~3,600-token API surface that fits beside system instructions.

**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](https://github.com/Sandflow-ai/sand3d?ref=explainx) 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](https://explainx.ai/blog/nvidia-cosmos-data-factory-two-prompts-physical-ai-datasets-november-2026)**, **[robotics code generation](https://explainx.ai/blog/forceharness-frozen-frontier-models-force-robot-harness-2026)**, and **[agent tool design](https://explainx.ai/blog/rust-anything-incremental-rewrite-recorded-parity-mcp-2026)**: 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](https://github.com/Sandflow-ai/sand3d?ref=explainx) 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:

``` python
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](https://github.com/Sandflow-ai/sand3d?ref=explainx)*

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](https://explainx.ai/blog/nvidia-cosmos-data-factory-two-prompts-physical-ai-datasets-november-2026)** to **deployable URDF**.

## Token efficiency: what Sandflow measures

Token count chart comparing sand3d to Blender Python for LLM 3D code
*Image: [Sandflow](https://github.com/Sandflow-ai/sand3d?ref=explainx)*

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](https://explainx.ai/blog/replica-skill-eleven-claude-skills-clone-any-app-recon-entrepreneur-guide-2026)** 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](https://explainx.ai/blog/what-is-mcp-model-context-protocol-guide)** 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:

1. Pin **Python 3.13 + bpy 5.2** in your devcontainer or VM.
2. Paste **api.md** into system context once per session.
3. Ask the agent for **named parts** and**joint declarations** before mesh detail.
4. Run **`s3d.export`** to GLB for visual QA; URDF when sim semantics matter.
5. 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](https://sandflow.ai/sand3d/?ref=explainx) on Sandflow's site browses examples. For fine-tuning, pair programs with **[serverless SFT stacks](https://explainx.ai/blog/baseten-loops-serverless-sft-rl-training-glm-5-3-qwen3-6-per-token-billing-ga-what-docs-confirm-2026)** 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](https://explainx.ai/blog/anyps5-ps5-games-native-pc-no-emulator-how-relinking-works-2026)** or GPU harness containers.

## How sand3d fits explainx.ai's agent stack

sand3d does not replace **[LeRobot datasets on Lance](https://explainx.ai/blog/lerobot-v0-7-0-interactive-rollouts-disk-less-streaming-remote-policy-server-cosmos-3-yam-unitree-g1-2026)** or **[NVIDIA Cosmos factories](https://explainx.ai/blog/nvidia-cosmos-data-factory-two-prompts-physical-ai-datasets-november-2026)**. 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:

1. sand3d program from the agent
2. GLB preview for humans
3. URDF or USD for sim validation
4. 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](https://explainx.ai/blog/llm-agents-self-improve-without-prescribed-loop-mit-isola-2026)** 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:

1. Store programs in git and diff them in code review.
2. Replay agent trajectories in eval harnesses.
3. Compare mesh fingerprints with `s3d.fingerprint` style utilities documented in the README.

If your organization already runs **[Spaceship IDE on Cerebras](https://explainx.ai/blog/spaceship-ide-cerebras-realtime-llm-steering-github-2026)** 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](https://sandflow.ai/sand3d/?ref=explainx). 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](https://explainx.ai/blog/openai-inside-codex-sandbox-permission-profiles-november-2026)** and **[Microsoft agent frameworks](https://explainx.ai/blog/microsoft-agent-framework-pypi-1-26-credential-stealer-november-2026)** 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:

1. **Prompt and completion tokens** per part, including retries after export errors.
2. **First-pass success rate** : how often the program exports without a traceback.
3. **Edit cost** : how many tokens a follow-up change such as "make the holes 8 mm" needs.
4. **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

*Star counts and dataset names follow the Sandflow GitHub README as of November 19, 2026.*
