Introduction

Artisan went public on October 11–12: Apache-2.0 code on GitHub (initial commit 2026-10-11 11:27 UTC), a project page, the Artisan-Benchmark dataset on Hugging Face, and the paper (arXiv 2610.13947). It comes from Chuanxia Zheng's PVG lab at Nanyang Technological University, working with ETH Zurich, Oxford's VGG, Microsoft and Cambridge. You give it a text description and, optionally, reference images. It returns an articulated 3D asset: parts, joints, joint limits, mass, materials and collision geometry, checked in a physics simulator before it's accepted. Modality: text/image to articulated 3D asset, built by agents. Where to run it today: locally on Linux x86_64. It uses CPU rendering, and the agents run on an OpenAI API key.

What shipped

  • Pipeline code: a run.sh launcher, an install.sh that pins Blender 5.0.0 and Node 22, an agent orchestrator, and a CadQuery/Blender-based modeling SDK.
  • Exporters: URDF, MJCF, USD with UsdPhysics joints and mass, and an object.articulated.glb (glTF 2.0) that keeps the link and joint hierarchy.
  • Viewer: a local web inspector at 127.0.0.1:8765 with joint sliders, so you can move every hinge and slide before you export.
  • Benchmark: 100 reference assets from ArtVIP and LightWheel, 50 stability prompts, and 50 ABO objects with reference masses, plus evaluators for fidelity, collision, stability and mass.
  • Announcement:
    , "Code and datasets" linked.

How it works

Artisan builds on Articraft, where a coding agent writes procedural geometry for an articulated object. Artisan splits that job across three roles and adds a physics gate.

Design, Coding, Review

  • Design agent: turns the prompt and reference images into a blueprint that lists parts, joint types, ranges and materials.
  • Coding agent: writes the procedural model against the Artisan SDK. The SDK has helpers for hinges, slides, rotary joints, wheels, gears, panels and telescoping parts.
  • Review agent: a separate agent judges the result, so the model that built the asset doesn't grade its own work.

Physics validation

The candidate asset is compiled and its joints are actuated in simulation. The checks cover parts colliding during motion, falling over at rest or mid-articulation, and implausible mass or inertia. Failures go back to the agents as repair instructions. Joint limits can be locked, so a repair can't "fix" a collision by shortening how far a door opens.

The numbers

These are the authors' figures from the project page and paper. Lower is better for collision.

MethodSingle-joint collision ↓Double-joint ↓Multi-joint ↓

Artisan (GPT-6 Astra)

1.7%

3.7%

13.0%

Artisan (GPT-5.5)

3.5%

6.4%

12.3%

Artisan (GPT-5.5), physics off

37.5%

47.3%

77.6%

Articulate-Anything

31.2%

39.2%

32.8%

Codex (GPT-6 Astra)

32.4%

47.0%

63.7%

Articraft (GPT-6 Astra)

45.5%

60.7%

78.8%

  • Stability: 98% at rest and 96% while articulated. The best baseline (Codex) is at 86% rest-state.
  • Human preference: Artisan was the first choice 43.3% of the time vs 21.1% for the next-best method.
  • The ablation: turning the physics loop off keeps the visuals about the same, but single-joint collisions jump from 3.5% to 37.5% on the same backbone.

Run it

git clone https://github.com/physicalvision/Artisan.git
cd Artisan
./install.sh                      # Ubuntu/Debian x86_64
# put OPENAI_API_KEY in .artisan/credentials.env
./run.sh doctor

./run.sh run "A wooden treasure chest with iron straps. The lid swings open 110 degrees on a rear hinge and a small drawer slides out of the front base."
./run.sh viewer                   # http://127.0.0.1:8765

  • Cost knob: the default model is GPT-6 Astra with high reasoning and a $15 budget per asset. You can change it with --model, --thinking and --max-cost-usd, or in .artisan/config.toml.
  • Images: add --image ref.png (repeatable) to steer appearance.
  • Hardware: the defaults use one CPU thread and CPU rendering. The heavy compute is the API calls, not your GPU.

Why game devs should care

Most open image-to-3D models give you one sealed mesh. A cabinet, chest or car door from those models still needs someone to cut it into parts, place pivots, set limits and build colliders before it can move in a game. Artisan's output already has that structure, and the physics gate catches the interpenetration that makes interactive props jitter or explode in an engine. The .articulated.glb and USD exports are the formats to try in Godot, Unity, Unreal or Omniverse pipelines. We haven't tested engine import ourselves yet.

Caveats

  • Built for robotics first: the benchmark and downstream tests target robot sims. Adding Artisan assets lifted task success from 80% to 84% on RoboTwin and from 39% to 43% on RoboCasa. Game-engine import isn't part of the evaluation.
  • Hard-surface, procedural look: assets are modeled in code (CadQuery and Blender primitives with stock PBR textures), so expect furniture, appliances and mechanisms rather than organic characters.
  • Paid API per asset: there are no local weights. Every generation spends frontier-model tokens, up to the budget you set.
  • Benchmark data licence: the HF dataset is marked "other". Check its terms separately from the Apache-2.0 code.

Conclusion

Artisan isn't a new mesh generator. It's an agent harness that treats "does it move without breaking?" as a pass/fail test. For anyone filling a level with doors, drawers, levers and loot chests, that's the part most text-to-3D tools skip. The code is open and runs today if you have an API key and a budget per asset.

—Titus