Caliper

Summary chart: “All results measured on one ASUS GX10: the size sweep doubled solved tasks (38% to 75%), and our fixed format
Repair loop: “The repair loop raised solved runs from 2 of 12 to 8 of 12 with one designer, and from 6 of 12 to 11 of 12 with four.”
“Running the GPU and CPU together brought the first passing design in 71 s, against 108 s in turns. The whole run took about the same time.”
Public benchmark: “On a public CAD benchmark subset, 64% of our fixed-format designs were one closed solid, against 36% for free-form code.”

Inspiration

Picture an engineer on an unreleased portable monitor. A few days before the design is due, she realizes nobody built the stand. There's no time to CAD it from scratch, and she can't hand the job to a cloud AI, because the monitor's dimensions are confidential.

AI CAD tools also have a deeper problem: they draw one shape and hope it fits. Language models are good at ideas and bad at exact dimensions. We wanted a tool that lets the model do the creative part and lets math do the precise part, on a machine that sits on your own desk.

What it does

Caliper designs 3D-printable parts that are checked to fit a specific device. You type (or say) something like "a desk stand that holds this screen at 70 degrees, keeps the USB-C port open, and prints without supports", and you get back a printable file with a report showing which checks it passed.

Design is treated as a search, not a single guess:

Device twin. A small JSON file describes the real device: its size, its ports and how it rests.
Many designers at once. 16 copies of a local model each propose a different idea, such as a cradle, a wedge or a kickstand.
A size sweep. Each design leaves its sizes open as ranges, and the CPU tries 64 extra combinations per design.
Exact checks. A CAD engine places the twin in the part and runs nine checks, including collision, blocked ports, tilt angle, tipping, print bed fit and overhangs.
Repair. A failed design gets exact fixes first. If those don't help, the model sees the failure numbers and a picture of the part and suggests a small edit, which is kept only if the checks improve.

A design goes green only when it passes every check. The model's opinion never decides whether a part fits.

How we built it

Everything in the design pipeline runs on the ASUS Ascent GX10.

Model: Qwen3.6 with vision, served by llama-server on the GX10's GPU.
Grammar: the model can only answer in a fixed format of 13 building moves (box, cylinder, cut, hole, fillet and so on). The model server enforces it, so every reply is a well-formed design.
Compiler: our own code turns that format into a solid with CadQuery on OpenCascade. No model-written code ever runs.
Checker: CadQuery, numpy, scipy and trimesh across 16 worker processes, with Latin hypercube sampling for the size sweep.
App: a FastAPI server pushes events over a WebSocket to a React and three.js front end, with a live design grid, a 3D viewer and a hardware dashboard. The site is served from the GX10 itself.
Voice: optional voice input through ElevenLabs. Only the spoken request leaves the box; the twin, the designs and the checks stay local.

The GPU writes designs while the CPU cores check geometry at the same time, on one pool of shared memory. We froze four data formats first so two people could build separate halves and have them connect.

Challenges we ran into

Our first repair loop didn't work. When it only asked the model for fixes, it added no solved runs (6 of 8 with or without it). We put exact, non-AI fixes ahead of the model and measured again.
The CAD engine can hang or deadlock. Odd shapes can stall it, and copying a process that already runs it can deadlock. We start each worker fresh and give every build a 5-second limit.
We changed model stack mid-build. We planned on Nemotron with vLLM and ended up on Qwen3.6 with llama-server.
Time. We are a two-person team and started late, so the website was built against a recorded run before the engine was ready.

Accomplishments that we're proud of

A repair loop with exact fixes first solved 11 of 12 runs, against 6 of 12 without it.
The size sweep doubled solved runs in our tests, from 3 of 8 to 6 of 8.
Our fixed format used about a quarter of the tokens of free-form CAD code (about 1,000 against 4,200 per design) and built a valid solid more often (58% against 33%).
Every number we quote is generated from logged runs, including the ones that went against us.

What we learned

Let each part do what it's good at. The model picks shapes, a sweep picks sizes, and geometry decides what passes.
Exact fixes beat asking the model. With 4 designers, the loop kept 39 edits from exact fixes and 9 from the model.
More designers isn't always better. 4 designers solved more runs than 1, but 16 did no better than 4 in our sample.
Running GPU and CPU work together brings the first result sooner (71 s against 108 s), but the whole run takes about the same time.
Our samples are small. Each experiment has only a few tasks, so these results suggest more than they prove.