The AI-Native CAD kernel — kernel + MCP + manufacturable parts, all in one. (formerly CADSolver)

The CAD kernel is a dependency of your product,
not a service your product calls.

You are building a quoting bot, a configurator, a design-review agent, a generative loop — something that has to reason about a real part. This is a solid modeling kernel you npm install. It runs in your process: in Node, in the browser, and inside the agent. Your customers' geometry never leaves your infrastructure, and your bill does not grow with your traffic.

npm install https://featureboard.ai/nativecad/releases/nativecad-kernel-0.3.2.tgz     # as a library (licence key required)
npx -y https://featureboard.ai/nativecad/releases/nativecad-mcp-0.27.0.tgz  # as an MCP server your agent installs itself

Formerly @cadsolver/kernel and cadsolver-mcp; the old MCP command still ships as an alias, so existing installs keep working. Direct downloads: nativecad-mcp.mcpb (Claude Desktop bundle) · nativecad-mcp.plugin (Claude chat plugin) · nativecad-mcp-v0.27.0.tgz · every way in

Quickstart for AI products Licensing Free for non-commercial and evaluation use. No call quota.

Three things, each with its proof

CAD that installs like a library

Pure JavaScript, zero runtime dependencies. No WASM, no native module, no Python sidecar, no build toolchain — which is also why an agent can install it for itself.

The MCP server, every tool over stdio →

Real B-rep in, real STEP out

An exact entity graph with addressable faces and edges — booleans, rolling-ball blends, chamfers, patterns, shells, holes, and a sheet-metal surface that folds a flat pattern into one watertight solid and comes back out as a flat-pattern DXF — read from STEP, IGES, Parasolid (x_t/x_b), SolidWorks parts, SAT, 3MF, mesh and laser-cut DXF drawings (a sketch, or an exact flat part from a thickness), and written as STEP AP242 that another CAD system opens, or as Parasolid, SAT, 3MF, glTF/GLB, USD/USDZ and 3D PDF/PRC.

Interop and round-trip → Every tool, with its schema →

cad_design_knowledge — the DFM knowledge packs, browse them.

Fasteners: cad_fastener places them from one station table, cad_fastener_audit proves them seated — zero findings before ship.

Your cost does not grow with your traffic

One licence per developer per year. Unlimited geometry operations, no per-second meter, no phone-home. The optimiser that tries 5,000 variants costs the same as the one that tries five.

The arithmetic, in public →

Install — four ways in, one release

Everything below is served from this site's own release directory and named, with sizes and checksums, in releases/latest.json — currently v0.27.0 (2026-10-28). Node.js 18 or newer for the npm routes; the Claude Desktop bundle needs nothing else.

Claude Desktop / Cowork

Download the bundle and open it — it installs as an extension. Then ask for a part.

nativecad-mcp.mcpb
sha256see latest.json

Claude chat plugin

Open the plugin in Claude, or attach it in a chat and press Save. You get every CAD tool plus a skill that knows how to drive them.

nativecad-mcp.plugin
sha256see latest.json

Claude Code, Cursor, any stdio MCP client

One command, no install step — point your client's MCP config at it and the agent has every tool:

npx -y https://featureboard.ai/nativecad/releases/nativecad-mcp-0.27.0.tgz

npm installs straight from the tarball URL (download it, ); the registry name nativecad-mcp is reserved for the same package.

sha256see latest.json

Kernel SDK, for products

The same kernel as a library, for Node:

npm install https://featureboard.ai/nativecad/releases/nativecad-kernel-0.3.2.tgz

A license key is required. Commercial: pricing. Non-commercial (education, research, makers): keys are issued case by case — request one at support@featureboard.ai. Then cad.setLicenseKey('CSLV1-…'), or set CADSOLVER_LICENSE_KEY — a machine already activated with cad_license needs nothing more. Download the tarball.

The SDK API reference → The tool reference →

Free keys report failures. A free key, from /register or a non-commercial key, always sends a report when NativeCAD fails. It sends what broke, the version, your key id, the kinds of input (never the values), and a small test case that a computer builds from simple shapes. It never sends your models, files, names or typed text, and a bug report you write by hand has its file paths, file names, part, body and parameter names, engraved text and matching coordinates removed first. After a failure, NativeCAD uses some of your computer's processor in the background to build the test case. Free keys have no off switch. Paid keys can turn failure reporting off with their licence. Turning it off also stops the background work. Exactly what is sent.

A quote, in twenty lines

A customer uploads a STEP file. You answer with the geometry facts a price depends on. Millimetres and radians throughout — there is no unit argument anywhere in the API.

const cad = require('@nativecad/kernel');
cad.setLicenseKey(process.env.NATIVECAD_KEY);   // a key is required — see pricing

// Parse + tessellate in one call. `parser` is the live B-rep, not a mesh dump.
const res = cad.solveStepFile('uploads/bracket.step', { targetCount: 20000 });

// What it is.
const props = cad.MassProperties.compute(res.mesh);   // volume, centroid, inertia
const stats = cad.GeometryStats.getStats(res.parser); // the read a quoting front-end needs

// What it costs you to make it.
const DENSITY_AL_6061 = 2.70e-6;                      // kg/mm^3
const massKg = props.volume * DENSITY_AL_6061;

// Whether you should quote it at all.
const { parser, solidId } = cad.ops.primitives.box(20, 20, 10);
const dfm = cad.ops.dfmRules.checkRules(parser, solidId, { process: 'machining' });
// dfm.approved / dfm.blockedBy / dfm.findings — each violation attributed to a face

The same kernel meshes to constrained-Delaunay tets and writes Nastran, Abaqus or VTK decks, and the ~135 KB gzipped viewer renders the result client-side with no server round-trip.

Stacked against the alternatives

Competitor figures read from their public pricing pages on 27 August 2026.

NativeCAD Hosted CAD APIs
(Zoo, Autodesk APS)
Converter SDKs
(CAD Exchanger)
C++ / WASM kernels
(OCCT, CadQuery)
Where geometry runs Your processTheir cloudYour process or their cloudYour process
Unit of price Flat, per year — a seat to design, one SDK licence to ship Per second / per credit
Zoo: $0.0083/s. APS: 4–6 credits/hr
Subscription
$590–$2,690/yr
Free
Cost at 10× your usage Unchanged10×UnchangedUnchanged
Install npm installAPI keySDK per platformA build toolchain
Your agent can install it unaided Yes — one npx lineNeeds a key and an accountNoNo
Customers' geometry leaves your network NeverEvery callDependsNever
Models and answers manufacturing questions Model, mesh, DFM, mass properties, CAE exportModel (analysis varies)Convert and visualise onlyModel — analysis is yours to write
Ship it inside your product Kernel SDK — one flat licence, no developer countN/A — it is a servicePer licence termsPer licence terms (OCCT is LGPL)

When the geometry has to live inside your product and your customers' data has to stay inside your network, this is the kernel built for that job.

Run the numbers — flat wins

Per-second CAD looks cheap until your product works. At Zoo's posted $0.0083 per second, against our published prices, and assuming a geometry call takes about eight seconds:

Flat licence Engine-seconds the same money buys Calls per year Break-even
MCP / Modeler seat — $200/yr24,096 s (≈6.7 hours)≈3,000≈250 calls / month
Kernel SDK — $9,995/yr1,204,217 s (≈335 hours)≈150,500≈12,500 calls / month

Past roughly 250 geometry operations a month, a $200 seat has already beaten per-second CAD — and it stays flat at 25,000 and at 2,500,000. A quoting bot serving forty RFQs a working day crosses that line in its first week. The costs a price list never shows land on the same side: a network round-trip per operation is fatal to an interactive configurator, and someone else's uptime becomes your core feature's uptime.

Two prices. Use it, or ship it.

Design with NativeCAD on a flat $200 seat. Put it inside the product you sell with one flat SDK licence — no developer count. Same kernel everywhere: no feature gates, no call quota, no meter.

Education / Maker

$0 — non-commercial, education and evaluation use. Full kernel, unlimited volume, the same bundles every paid tier gets. The viewer carries a "Powered by CADSolver" watermark; nothing else differs.

NativeCAD MCP / Modeler

$200/seat/yr — the licence to design with NativeCAD: the full kernel, driven through nativecad-mcp. Flat by commitment — no metered agent compute, ever; your agent runs on your own model account. About 7% of the SOLIDWORKS seat it displaces.

NativeCAD Kernel SDK

$9,995/yr — the licence to ship it: embed and redistribute the kernel inside your product as compiled bundles. One flat price for the whole company — no developer count. Read the SDK API reference →

Custom / OEM

White-label embedding, custom builds, site licences, negotiated volume — support@featureboard.ai.

Full terms and checkout Every plan ships the same full kernel. Automatic Support — agent-delivered, 24/7/365 — is $499/yr on any of them.

The questions you are about to ask

JavaScript, for a CAD kernel?

It is written from scratch, with no opencascade.js or other engine underneath, and the language turned out to matter less than the proof: variable-radius rolling-ball blends across corners of any valence, exact spherical corner patches, watertight tessellation, STEP AP242 out. Run the benchmark suite before you decide.

What happens if you disappear?

The bundles you installed keep working: the kernel runs entirely on your machine, with no hosted component to switch off. Continuity terms for OEM deployments are negotiated on the custom path. The licence check is offline and never a runtime kill-switch: an expired key still validates and nothing stops running. A hosted API cannot give you that continuity.

Is it as complete as OpenCascade?

It covers the path this segment walks end to end: import, model, measure, check for manufacturability, mesh, export, view. It installs in ten seconds instead of an afternoon, and PMI lives on the 3D model. OpenCascade has more surface area, and the one gap that matters here is drawing output for agents. NativeCAD lays out dimensioned 2D sheets (SVG, DXF and PDF) from a command-line script, but no agent tool asks for one. Drawing import is covered on Drawings to STEP.

Can I ship it to my customers?

Yes — that is the Kernel SDK licence: embed and redistribute the kernel in the product you ship as compiled bundles, with no developer count. A Modeler seat licences design work, not redistribution; white-label and custom-build terms are negotiated on the custom/OEM path.

Do you meter anything, ever?

No. The kernel runs on your CPU, so there is no per-call meter and no phone-home; there is nothing for us to meter. If we ever offer hosted execution it will be a separate, clearly priced product, and the library you embedded stays flat.

Competitor figures are quoted from public vendor pages as of the date above the table, and we correct them the day a vendor tells us one has changed. Zoo, Autodesk (APS), CAD Exchanger, OCCT, OpenCascade.js and CadQuery are named to identify each row's offering; they are their owners' marks and NativeCAD is not affiliated with or endorsed by them. Site-wide notices are on one page: legal notes.