Axle Keys — local CAD engine

Build parametric CAD models in JavaScript, run them on your own machine, and get the same verdict axlekeys.com gives — offline, in about 55ms.

This is the real execution path, not a demo: packages/engine/runner.mjs is the file the hosted geometry service imports, at the same paths, so a stack trace here matches a stack trace there.

Install

Requires Node 23 or newer — the engine ships as source and imports TypeScript directly, which Node runs natively from 23 onward. There is no build step. The CLI checks this first and tells you so rather than failing inside a module loader.

git clone https://github.com/AxleKeys/cad-engine.git
cd cad-engine
npm install
node packages/engine/cli.mjs build examples/side-table.js

That last line is the command this repo's own release check runs before publishing, so it is known to work on the files you just cloned.

To get axle on your PATH instead of typing the full path:

npm link          # from the repo root
axle build examples/side-table.js

Use

axle build  model.js                 # verdict: dimensions, per-part boxes, problems
axle build  model.js --json          # the same, machine-readable
axle watch  model.js                 # rebuild on every save, ~55ms
axle repl                            # paths on stdin, one JSON verdict per line
axle export model.js --step --stl    # real CAD files
axle build  model.js --param topSize=700

⏱ Use watch or repl for real work. A one-shot axle build spends ~900ms starting Node and the OpenCascade kernel to do ~100ms of building. The persistent modes pay that once and then rebuild in ~55ms — measured at 19.8× faster than the one-shot on the same machine.

A model

A model is a function that returns named parts. Parameters are annotated consts, which is what makes --param work — a dimension is a parameter, not a coordinate to edit.

const topSize = 450;      // [300:800]
const height  = 500;      // [350:700]

const main = ({ makeBaseBox }) => {
  const top = makeBaseBox(topSize, topSize, 25).translateZ(height - 25);
  return [{ name: "Top", shape: top }];
};

What the verdict checks

Deterministic rules, the same implementations the hosted platform runs:

• part_interference — a measured solid intersection between two parts, not a bounding-box guess. A dado joint shares faces and stays silent; a collision is reported with the shared volume in mm³.
• unsupported_part — a part with nothing beneath it. Conservative by design, and it only understands bearing from below, so it can flag legitimate end-supported joinery.
• empty_mesh, degenerate_dimension, empty_parts_array.

A finding marked unverified means the build could not measure that pair in the time it allowed itself. It is reported, and it does not fail the model — "I could not tell" is not "there is a defect".

Skills — teach your agent the whole workflow

The engine above runs on your machine. These skills are the other half: choreography for an agent driving the hosted platform at axlekeys.com, over MCP.

Skill	Tier	What it does
brief-to-model	Free	Turn a plain-English description into a real parametric 3D CAD model — built, dimension-verified, and shown back as a picture you can spin.
design-loop	Free	Verify an agent-built CAD model with independent critics instead of self-review — clean-context reviewers that fetch the reference and probe the geometry themselves, then a punch list you gate on.

Every skill here is completable on the free tier — that is enforced at export time, not promised, so nothing in this repo walks you into a paywall. Install one the way your agent takes skills (for Claude Code, drop the folder in .claude/skills/), and connect Axle:

https://api.axlekeys.com/mcp

What this is not

This runs models. It does not store them.

Persistence, versions, the 3D viewport, assemblies, motion, configurators, shop drawings, cut lists and nesting, materials and textures, the knowledge layer, and the MCP interface your agent drives all live on axlekeys.com.

This package is a calculator; the platform is the notebook. It does sums. It doesn't remember anything, show you anything, or let you sell anything.

It is also read and run, never write. Local edits change your copy, not Axle — if the two ever disagree about the same model, the server is the one that counts.

Contents

Generated from the Axle Keys repository — 9 source files, derived by walking the engine's own imports. Do not hand-edit; changes are made upstream and re-exported.

Pinned: replicad@0.23.0 · replicad-opencascadejs@0.23.0

License

MIT.