<div align="center">
<img src="https://raw.githubusercontent.com/earthtojake/text-to-cad/HEAD/apps/docs/public/brand/logo-texttocad-animated.svg" alt="text-to-cad" width="800">
Design physical products with AI.
[Website](https://www.texttocad.dev)
[](https://pypi.org/project/cadgen/)
[](https://github.com/earthtojake/text-to-cad/actions/workflows/test.yml?query=branch%3Amain)
[](LICENSE)
[](https://skills.sh/earthtojake/text-to-cad)
[](https://pepy.tech/projects/cadgen)
[](https://discord.gg/5FGB9DwJYU)
[](https://x.com/earthtojake)
[](https://github.com/sponsors/earthtojake)
</div>
# text-to-cad
The text-to-cad plugin gives your agent local workflows for generating 3D models
as STEP, GLB, STL or 3MF files. It also does design for manufacturing checks,
generates engineering drawings, and connects to popular 3D printing, sheet metal
and CNC fabrication services.
It is supported by all popular agents that support plugins or the
[skills](https://skills.sh) framework, including Claude Code, Codex, Cursor,
Gemini and Grok.
### How it works
1. Your agent writes each model as a Python script with [build123d](https://github.com/gumyr/build123d), built on [Open CASCADE](https://dev.opencascade.org).
2. Running the script, `python model.py`, builds the model with cadgen's engine
into an `.xbf` document (its parts, names, colours, materials and joints) and
the STEP, GLB, STL or 3MF files the script declares. The engine keeps each
model's work in memory, so an edit rebuilds only what it changed.
3. The CAD viewer shows the model in your agent app or your browser, and follows
every rebuild.
## 💻 Install
### Ask your agent (recommended)
Send this message to your agent and it will install text-to-cad for you.
```text
Install text-to-cad from https://github.com/earthtojake/text-to-cad
```
By default, text-to-cad sends usage stats and crash reports, tagged with a random
ID and never including your files, paths or prompts; turn them off with
`uvx --no-config --managed-python --python 3.13 --from cadgen==0.8.3 cadgen telemetry off`, or ask your agent to. [Telemetry](#telemetry) says
the rest.
The runtime supports Python 3.11+; the launch commands use uv-managed Python 3.13.
Or install it yourself:
1. CAD runs through [uv](https://docs.astral.sh/uv/): check that it is installed
(`uv --version`), and if it is missing, install it with
[uv's installer](https://docs.astral.sh/uv/getting-started/installation/).
2. Run the commands under your agent app's heading below, or under
[Other Agents](#other-agents) if it has none.
3. Restart the app. Its first start downloads CAD's runtime, so it needs a network
connection.
The plugin for your agent app brings the skills and CAD's viewer, a local server
(`cadgen mcp`). For an agent without a plugin, install the skills alone. Install
one or the other in an app, not both: two copies means every skill twice.
The install commands below take the `latest` branch: it holds the plugin alone
and gets each release once it is on PyPI. `main`, where development happens,
installs too, but can hold changes that aren't released yet. Each app names the
branch in its own way (`#latest`, `--ref latest`, `@latest` or
`--branch latest`); leave it out and the app installs `main`.
Each app's heading also says how to update text-to-cad, and how to reinstall it:
remove it, then install it again. Updating the plugin updates CAD: the new
release's cadgen is downloaded the first time it runs, and the skills and the
server share it. Earlier releases stay in uv's cache until you run `uv cache prune`.
### Claude Code
```bash
claude plugin marketplace add earthtojake/text-to-cad#latest
claude plugin install text-to-cad@earthtojake
```
The plugin also starts CAD's server. Where Claude Code can show app views, CAD
shows models as viewer cards in the conversation; otherwise, as in a terminal,
asking it to show a model gives you a link that opens the model in the CAD
Viewer in your browser.
To update, run these, then restart Claude Code:
```bash
claude plugin marketplace update earthtojake
claude plugin update text-to-cad@earthtojake
```
To reinstall, remove it with these, then run the install commands again:
```bash
claude plugin uninstall text-to-cad@earthtojake
claude plugin marketplace remove earthtojake
```
### Claude Desktop
CAD shows models in the chat: ask Claude to show one and it appears as a viewer
card you can orbit, add to your prompt, and open full size; Claude can read what
you selected and see what you see. It runs locally through uv: add the server to
Claude Desktop's config (Settings > Developer > Edit Config), then restart the
app. If Claude Desktop cannot find `uvx`, give its full path (`which uvx`).
```json
{
"mcpServers": {
"cad": {
"command": "uvx",
"args": ["--no-config", "--managed-python", "--python", "3.13", "--from", "cadgen==0.8.3", "cadgen", "mcp"],
"env": {"CADGEN_INSTALL_CHANNEL": "claude-desktop"}
}
}
}
```
The config pins a cadgen release in `args`, and uvx keeps the version it first
downloads. To update, change that version to the
[latest release](https://pypi.org/project/cadgen/), then restart Claude Desktop.
### Codex
Install text-to-cad from Codex's plugin directory:
[text-to-cad for Codex](https://chatgpt.com/plugins/plugins_6ac09476ef008191a35887b22b0d048a),
then **Open in desktop app**.
In the Codex app the plugin also brings the CAD viewer: **CAD** in the sidebar
(recent models, and Open), a **CAD** tab beside each thread that the agent
drives, and *Open with CAD* for model files.
<details>
<summary>Manual install</summary>
```bash
codex plugin marketplace add earthtojake/text-to-cad --ref latest
codex plugin add text-to-cad@earthtojake
```
To update, upgrade the `earthtojake` marketplace (or use Plugins › Manage ›
Marketplace), then restart Codex:
```bash
codex plugin marketplace upgrade earthtojake
```
To reinstall, remove it with these, then run the install commands again:
```bash
codex plugin remove text-to-cad@earthtojake
codex plugin marketplace remove earthtojake
```
The marketplace was renamed from `text-to-cad` to `earthtojake`; if you added it
before, remove the old one first (`codex plugin marketplace remove text-to-cad`).
</details>
### Cursor
Cursor also loads the plugin installed with Claude Code. If the Claude Code plugin
is installed, Cursor already has text-to-cad: skip this.
```bash
git clone --depth 1 --branch latest https://github.com/earthtojake/text-to-cad ~/.cursor/plugins/local/text-to-cad
```
Cursor reads `.cursor-plugin/plugin.json`: restart Cursor after cloning. Teams
can import the repository instead, under **Dashboard → Plugins & MCPs → Team
Marketplaces**.
To update, pull the latest release, then restart Cursor:
```bash
git -C ~/.cursor/plugins/local/text-to-cad pull
```
To reinstall, delete the folder, then run the install command again:
```bash
rm -rf ~/.cursor/plugins/local/text-to-cad
```
### Grok Build
Grok Build also loads the plugin installed with Claude Code. If the Claude Code
plugin is installed, Grok Build already has text-to-cad: skip this.
```bash
grok plugin install earthtojake/text-to-cad@latest --trust
grok plugin enable text-to-cad
```
Grok Build reads the Claude plugin manifest. Grok shows tool results as text, so
asking it to show a model gives you a CAD Viewer link.
To update, run this, then restart Grok Build:
```bash
grok plugin update text-to-cad
```
To reinstall, remove it with this, then run the install commands again:
```bash
grok plugin uninstall text-to-cad
```
### Gemini
```bash
gemini extensions install https://github.com/earthtojake/text-to-cad --ref latest --consent --auto-update
```
Gemini installs the plugin as an extension, with the skills and CAD's server, and
keeps it up to date (`--auto-update`; `--consent` answers its security prompt). Like Grok, it shows tool results as text, so asking it to show a model
gives you a CAD Viewer link.
To update now, run this, then restart Gemini:
```bash
gemini extensions update text-to-cad
```
To reinstall, remove it with this, then run the install command again:
```bash
gemini extensions uninstall text-to-cad
```
### Other Agents
For an agent without plugin support: the skills give you everything you need for
core CAD workflows and let you view CAD files in a localhost web app. Install them
with the Skills CLI:
```bash
npx skills add earthtojake/text-to-cad#latest
```
The command asks which agents to install for, and where. To skip the questions,
name the agent and install for your user:
`npx skills add earthtojake/text-to-cad#latest -g -a <agent> -y`.
Each skill runs cadgen through uv with the same pinned command the plugin's server
uses, so uv must be installed. Without the plugin there is no CAD server, so the
skills open models in the CAD Viewer in your browser.
**To update or reinstall, run the same command again**, then restart the app.
`add` re-fetches the package and overwrites what is already installed, so it both
refreshes existing skills and installs any skill added in a newer release.
`npx skills update` only refreshes skills already in your lockfile, so it silently
misses new ones — which matters here, because releases do add skills.
Neither command removes a skill that was retired upstream; drop one with
`npx skills remove <skill>` if you need to. The retired `cad-viewer` skill is
now covered by the CAD, DXF and robot-description skills, and the retired
`cad-mcp-setup` by this README's install and update steps. Remove old standalone
installs with `npx skills remove cad-viewer cad-mcp-setup`.
No plugin for your agent yet?
[Request one](https://github.com/earthtojake/text-to-cad/issues/new?title=Plugin%20request%3A%20).
### Updates
To update, ask your agent to update text-to-cad, or run the update commands under
your app's heading, then restart the app.
When a newer release is out, a copy you installed yourself says so: a blue update
button, first in CAD's navbar and on its home, whose **Send to agent** posts
"Update text-to-cad to 0.9.0 from https://github.com/earthtojake/text-to-cad" to
your chat, worded like the install message (the browser viewer's copies it
instead), or, in an app that shows CAD's replies as text, a line with its reply.
Your agent then runs the update commands under your app's heading here. The button
also links to the [install instructions](https://www.texttocad.dev/install), to
update by hand. Copies from a plugin directory or the Cursor Marketplace never
show it, since their store updates them, and neither does Gemini's extension,
which Gemini updates: for those there is nothing to run.
To find out, cadgen fetches `api.texttocad.dev/v1/versions` at most once a day:
one anonymous request, with no ID, path or anything about you, never in CI and
never for a copy that something else updates. `CADGEN_UPDATE_CHECK=0` turns it off.
A CAD project written for cadgen 0.7 needs porting to 0.8:
[the migration guide](https://github.com/earthtojake/text-to-cad/blob/HEAD/docs/migrations/migrating-0.7-to-0.8.md) takes one across, step by
step, and an agent with the CAD skill can follow it.
### Telemetry
The CAD app (the plugin's `cad` server) and the browser viewer (`cadgen viewer`) send usage stats by default, with
what every `cadgen` command and model script counted, tagged with a random install ID: versions, where you installed
it from (as the plugin's CAD app names it, noted in cadgen's state folder for the rest), your OS and agent app, and
counts -- how often each CAD tool was called and why a call failed (one of a fixed set of words, such as "no file at
that path" or "no view open", never its message), how often views were used, how many files of each format were
shown, how many models were built and exported and snapshots drawn, how those ended, why one failed (again a fixed
word, such as "the model's code raised" or "the geometry kernel refused", never its message) and how long they took,
which features were used, and how many of the engine's warm workers started, crashed or were retired -- added up over
a few minutes before they are sent, each batch under a random ID of its own and the time it was made, so one sent
again is counted once. When cadgen's own
code fails, they also send a crash report: the error's type and where in cadgen (or Python, or one of its
dependencies) it failed, never its message, and with any of your own code a bare placeholder. Our server adds the country each request
comes from (worked out from its IP address, which it doesn't keep) and stores it all with PostHog. Never file names,
paths, contents or prompts. The first `cadgen` command says so once, and sending starts then. Turn it off, which
also deletes what was sent, with `uvx --no-config --managed-python --python 3.13 --from cadgen==0.8.3 cadgen telemetry off`, **Telemetry** in either app's menu (the logo at
the top left, over any model), or by asking your agent. `DO_NOT_TRACK=1` or `CADGEN_TELEMETRY=0` turns it off for
one process, and `CADGEN_TELEMETRY=1` on, without changing your setting; nothing is sent by default in CI or from a
development install. Nothing waits to send: a command or a model script sends nothing itself, and what it counted,
like what any part of cadgen counted since its last send when it exits, waits in small files in cadgen's state folder
until the CAD app or the viewer sends it in the background -- or, when nothing has for five minutes, a short-lived
sender the next command starts, which sends it and exits; turning telemetry off deletes them.
Offline, nothing is sent and everything works. See
the [privacy policy](https://www.texttocad.dev/privacy-policy).
### Windows 11: Smart App Control
The CAD kernel behind the `cad`, `dxf`, `urdf`, `srdf` and `sdf`
skills is `OCP`, OpenCascade's Python binding, and its wheel ships an unsigned
native module. Windows 11's Smart App Control blocks unsigned native code, so
on a machine where it is on (the default on a fresh install) every `cadgen`
command and `import build123d` fails with
`ImportError: DLL load failed while importing OCP`, and Event Viewer records
the refusal as Event ID 3077 under CodeIntegrity › Operational. `cadgen doctor`
names this when it sees it.
Smart App Control has no per-app exception. Either turn it off (Settings ›
Privacy & security › Windows Security › App & browser control › Smart App
Control settings; once off it can only be turned back on by reinstalling
Windows) or run the CAD skills under WSL, where it does not apply. The wheel
is built by the cadquery-ocp project, so signing it is not something this
repository can do.
## 🧰 Skills
Install the library to give agents focused workflows for CAD, fabrication,
robot description files, simulation, and local review.
| Skill | Summary | Source |
| ------------ | -------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------- |
| CAD | Creates and edits CAD models from plain-language or image requests as Python scripts, built into XBF documents with STEP, STL, 3MF and GLB exports. | [skills/cad](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/cad/SKILL.md) |
| step.parts | Finds off-the-shelf STEP parts like screws, bearings, motors, and connectors. | [skills/step-parts](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/step-parts/SKILL.md) |
| Engineering Drawing | Dimensioned engineering drawings from a part, as a PDF: views, hidden lines, dimensions, hole callouts, title block. | [skills/engineering-drawing](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/engineering-drawing/SKILL.md) |
| DXF | Creates 2D DXF drawings like profiles, templates, gaskets, and cut layouts from Python sources or CAD geometry. | [skills/dxf](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/dxf/SKILL.md) |
| URDF | Writes robot structure files with links, joints, limits, inertials, and meshes. | [skills/urdf](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/urdf/SKILL.md) |
| SRDF | Adds MoveIt planning groups, end effectors, poses, and collision rules to a URDF. | [skills/srdf](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/srdf/SKILL.md) |
| SDF | Creates simulator models and worlds with frames, physics, sensors, and lights. | [skills/sdf](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/sdf/SKILL.md) |
| SendCutSend | Checks DXF and STEP files before upload to SendCutSend. | [skills/sendcutsend](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/sendcutsend/SKILL.md) |
| DfAM Check | Measures mesh printability per process: wall thickness, overhangs, support volume, and build orientation. | [skills/dfam-check](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/dfam-check/SKILL.md) |
| DFM | Reviews a part for sheet metal, CNC machining, or injection molding, with measured evidence and the cited rule behind every finding; measures draft, undercuts and projected area from a mesh. | [skills/dfm](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/dfm/SKILL.md) |
| G-code | Slices models into printer-ready G-code with OrcaSlicer, using your own printer presets. | [skills/gcode](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/gcode/SKILL.md) |
| Bambu Labs | Sends prints to Bambu Lab printers through Bambu Connect, Bambu Lab's official app, or Bambu Studio. | [skills/bambu-labs](https://github.com/earthtojake/text-to-cad/blob/HEAD/skills/bambu-labs/SKILL.md) |
## 🛠️ Contributing
Branch from `main` and open PRs against `main`. For the local workflow, testing in
agent apps and validation, see [CONTRIBUTING.md](https://github.com/earthtojake/text-to-cad/blob/HEAD/CONTRIBUTING.md); an agent working in
the repository starts at [AGENTS.md](https://github.com/earthtojake/text-to-cad/blob/HEAD/AGENTS.md). A security problem is reported privately,
as [SECURITY.md](https://github.com/earthtojake/text-to-cad/blob/HEAD/SECURITY.md) says.
<a href="https://trendshift.io/repositories/26559"><img src="https://trendshift.io/api/badge/repositories/26559" alt="earthtojake/text-to-cad | Trendshift" width="250" height="55"></a>
