cd /news/ai-agents/sand3d-python-3d-modeling-built-for-… · home › topics › ai-agents › article
[ARTICLE · art-172266] src=explainx.ai ↗ pub= topic=ai-agents verified=true sentiment=↑ positive

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

Sandflow-ai's sand3d Python 3D modeling library passed 2,150 GitHub stars by November 19, 2026, roughly two weeks after public development began on November 3, 2026. Sand3d represents 3D objects as short, named, deterministic Python programs rather than thousand-line Blender scripts, and Sandflow's README claims 2–6× fewer tokens per part versus Blender Python, CadQuery and FeatureScript, plus a ~3,600-token API surface that fits beside system instructions. The claims come from Sandflow's own documentation rather than independent labs, and the library targets agents that must emit geometry within context limits, including joint semantics that map to simulators such as Isaac and MuJoCo.

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.

by read9 min views4 publishedNov 19, 2026
sand3d: Python 3D Modeling Built for LLMs, Not Blender Scripts
Image: Explainx (auto-discovered)

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- 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:

  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 andjoint 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 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 bpy5.2 onward should stay onPython 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:

  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 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 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 —nochair() 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 despiteCHANGELOG.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 hashlockfiles in CI.
  • Scan exports before 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:

  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.

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

── more in #ai-agents 4 stories · sorted by recency
── more on @sandflow-ai 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/sand3d-python-3d-mod…] indexed:0 read:9min 2026-11-19 · —