Shpigford/nurb: Agentic CAD That Turns a Chat Prompt Into a Printable 3MF

The gap nurb is trying to close between a chat window and a slicer

Most AI-assisted 3D printing workflows end at a mesh. You get an STL, open it in a slicer, and discover the wall is too thin or the overhang needs support. nurb's premise is that the AI should be able to see the same failure before the file leaves the tool. The README frames it plainly: "The AI cannot see, so `nurb check` is its eyes." The intended user is someone who already pays for an AI subscription, prints on an FDM machine, and would rather describe a part in words than learn a feature tree. The repository's own classifiers describe it as Development Status :: 3 - Alpha, so this is a tool for people comfortable with a moving target, not for a production CAD seat.

A part is a Python function, and the function is the single source of truth

The architecture is unusually compact. A part is a decorated Python function whose default arguments are the parameters. The README gives this example:

from nurb import *

@part
def hose_adapter(vac_end=57.6, tool_end=35.0, wall=2.4):
    ...

That one line is where the viewer's sliders, the tests, and the CLI all come from. The body is build123d on the OCCT kernel, plus nurb's own vocabulary for printing-specific moves: `polish` for the chamfer pass, `stand` for a diagonal print stance, `measured` for real-world dimensions, `assembly` for multi-part builds. `nurb api` prints the whole list with signatures. Because a part is a function, variants are cheap: the README says a card can declare `shelf_3x2` as the shelf with `grid_x = 3`, and every command walks variants like parts, each with its own 3MF and baselines. The practical consequence is that the geometry is parametric by construction, not by a feature history you have to maintain. The trade-off is that the AI writes the function, and a wrong body produces a wrong solid with no intermediate UI to correct it by hand.

Installing nurb and modelling a first part

The README offers a Mac app for Apple silicon and Intel, which it says sets everything up on first open and updates itself. For the command line, the documented one-liner installs uv if missing, nurb, and the agent skill:

curl -fsSL https://nurb.dev/install.sh | sh

If you prefer your own package manager, the README states that `uv tool install nurb` (or `pip install nurb`) does the first half, and `npx skills add shpigford/nurb --skill nurb` teaches whatever AI harnesses you have. Later, `nurb update` upgrades nurb and the installed skill together. Note the Python requirement in pyproject.toml: `requires-python = ">=3.13"`. After install, name your machine once. The README says the config lives at `~/.config/nurb/config.toml` and gives this key:

profile = "bambu_a1_mini"

Every project on that machine then knows the bed: `nurb rules` prints it first, the viewer labels the plate with it, and check, slice, and export use it. To make something, the README's example prompt is: "Make an adapter that connects my shop vac hose to the dust port on my table saw." The AI reads the design doctrine, creates the project, models the part, runs the printability checks, and opens the live viewer. A project is any directory with a `parts/` folder; there is no init step, and new projects ship a `viewer.command` that opens the viewer from Finder. When the part looks right, click `3mf`.

Thirteen rules, and why exit 0 is the interesting default

The check list is the part of nurb with the most specific engineering behind it. The README enumerates thirteen rules that run against the exact solid rather than an approximation: `solids`, `overhang`, `floating`, `hole_ceiling`, `min_wall`, `sliver`, `concave_cosmetic`, `bed_bevel`, `warp_risk`, `pin`, `stability`, `projection_ratio`, and `build_volume`. Findings come back with coordinates and pin themselves to the exact faces they fired on. Two of these are worth calling out because they encode FDM experience rather than generic geometry: `floating` catches a region whose first layer would be laid on air, and `warp_risk` targets large first layers with corners likely to lift as they cool. The behavioural choice that matters most is the exit code. `nurb check` reports and exits 0 by default, so findings never block iteration; `--strict` makes findings fail the build, and the README says that is what CI runs. That split is sensible for an agent loop, where a hard failure on the first overhang would stop the AI from making progress, but it does mean a casual run can leave real problems unflagged unless you read the output.

Exports, stress simulation, and the parts that fit the real world

Exports default to 3MF with print settings the part justifies already embedded: infill, walls, and a brim when the checks say the corners will lift. STL, STEP, and GLB are, in the README's words, one flag away. STEP matters because the geometry is true B-rep on OCCT rather than a mesh, so chamfers and fillets are real operations and the part opens in Fusion or FreeCAD. There is also a stress path: clicking the stress button runs a voxel simulation that reports where load concentrates, how far the part sags, and the weight it breaks at, quoted against layer adhesion because that is where FDM prints actually fail. The third capability is measurement discipline. You can scan a real object with a phone or measure a downloaded model, record the dimensions that matter, and nurb refuses to let the AI guess them; a card with a target mesh gets deviation reports in both directions, so added material is caught as loudly as missing material. That last detail is the one that separates this from a prompt-to-mesh toy, because fit-critical parts fail on excess material as often as on gaps.

Where nurb is the wrong tool

The obvious limitation is the AI dependency. nurb does not model anything itself; it turns the AI you already pay for into a CAD partner. The README is candid that subscriptions are not equally good at designing parts, and points to nurb.dev/benchmarks for model comparisons. If you do not have a subscription, or your harness cannot load the skill, the core loop does not run. The second limitation is maturity. The package is classified Alpha, the version sits at 0.26.0, and releases land frequently: v0.24.0 on 2026-08-29, v0.25.0 on 2026-09-04, v0.26.0 on 2026-09-05. Rapid versioning is good for fixes and bad for stability, and the README does not document rollback or how project files survive a breaking change. Third, the print-time and filament-cost row drives OrcaSlicer or Bambu Studio specifically, so users of other slicers lose that feature. Finally, the offline claim covers modelling, checking, the viewer, and export, but the AI itself is a remote service, so "works offline" describes nurb's own components rather than the whole workflow.

How nurb differs from OpenSCAD and from prompt-to-mesh generators

The closest comparison in kind is OpenSCAD, which also describes solids with code. The difference is the kernel and the author. OpenSCAD evaluates its own language and produces meshes; nurb evaluates Python through build123d on OCCT and produces B-rep solids, which is why STEP export and real fillet operations are available. The other comparison is the family of text-to-3D mesh generators. Those emit a triangle soup with no parameters, no named dimensions, and no notion of a build plate, so a change means regenerating and hoping. nurb's parts carry named defaults that become sliders, and the checks run against the solid before export. The cost of that structure is that you inherit Python 3.13, a build123d dependency chain, and an AI that has to write correct code rather than plausible-looking geometry. If your parts are organic sculpts rather than mechanical fittings, a mesh generator is the better fit and nurb's rule set is mostly irrelevant.

Licence, upgrades, and what the repository does not say

pyproject.toml declares `license = "LicenseRef-FSL-1.1-MIT"`, which the metadata summarizer reports as NOASSERTION. That identifier points at the Functional Source License with an MIT future licence, a source-available model rather than a standard OSI licence. The practical reading is that the terms are not the MIT licence today, and anyone embedding nurb in a commercial product should read LICENSE directly rather than assume permissive terms. This is not legal advice. On upgrades, the README documents `nurb update`, which it says upgrades nurb and the installed skill together, and the Mac app updates itself. What the README does not document is a changelog, a deprecation policy, or a rollback command, so pinning a version before a big project is the prudent reading of the available text. The repository is not archived and the last push was on 2026-09-16, one day before this review, so the codebase is moving quickly in both directions.

Editorial conclusion

Adopt nurb if you already pay for an AI subscription, print on FDM, and want parametric B-rep parts you can export as STEP or a tuned 3MF without learning a CAD package. Skip it if you need a mature, stable toolchain: the package classifies itself as Development Status :: 3 - Alpha, requires Python 3.13, and the README does not document rollback or a migration path between releases. Before committing a project to it, verify that your harness can load the agent skill, that your printer profile exists in ~/.config/nurb/config.toml, and that nurb check --strict passes on a part you already know prints well.

Frequently asked questions

Official sources

1. Issues
2. Project website
3. README
4. Releases
5. Shpigford/nurb on GitHub