TL;DR

text-to-cad (earthtojake/text-to-cad) is a plugin and a set of agent skills that let coding agents produce real, editable CAD. You ask Claude Code, Codex, Cursor, Gemini or Grok for a part. The agent writes a short Python script with build123d on the OpenCascade kernel, runs it, and you get a STEP file. From there it can export STL, 3MF and GLB, draw dimensioned PDFs, check a part for manufacturing and slice it for a 3D printer. The repo’s tagline is five words: “Give your agent CAD superpowers.”

Facts as of October 9, 2026:

  • 18,595 GitHub stars, 1,849 forks, MIT license, written in Python. The repo was created on April 22, 2026, and gained 1,898 stars in the past week, according to GitHub Trending.
  • Latest release: v0.7.19 (October 9, 2026). It is the repo’s 80th release. The runtime ships on PyPI as cadgen, which pypistats counts at 11,281 downloads in the last week.
  • 1 open issue. Almost all commits come from the author: 1,127 by earthtojake. The next two contributors are the github-actions bot (102) and Claude (87).
  • Requirements: uv and a network connection on first start. cadgen itself needs Python 3.11 or newer; the skills pin Python 3.13 through uv.
  • Telemetry is on by default. Anonymous usage stats and crash reports go to PostHog; uvx cadgen telemetry off turns them off.

Our verdict: text-to-cad is the most complete open-source answer to “can my coding agent do CAD?” right now. It gives the model the tools that matter: a real B-rep kernel, STEP as the main output, geometry checks written in code, and a viewer. In our clean Linux container, though, it failed before making a single part. The CAD kernel would not load because a system library (libGL.so.1) was missing, and the README says nothing about that. It is a good fit for makers and robotics hobbyists who use Claude Code or Codex on a desktop. It is not yet a drop-in tool for headless servers or CI.

What problem text-to-cad solves

Language models can write OpenSCAD, but the model can’t see what it built, and the mesh output doesn’t carry exact faces and edges a professional CAD tool or manufacturer can use. text-to-cad keeps the model in a language it is good at (Python) and points it at a real parametric kernel. The author, who posts on Hacker News as softservo, described the goal in the May 2026 HN thread: “The purpose of this repo (harness and skills) is really to just give the models more direct tools to generate and inspect STEP files.” He built it for his own project: “I built this harness / skill to help me generate some basic CAD models for a 7dof robot arm I’m designing. It ended up working much better than I expected, particularly on the latest GPT 5.5 and Opus 4.7 models.”

He is also open about the main limit: much of the skill text is there “to plan for more complex parts (this is mostly a stop gap while the models don’t have amazing spatial reasoning).”

How it works

text-to-cad has three layers, per the README and the shipped skill files:

  • cadgen, the runtime. A Python package on PyPI that wraps build123d and OCP (OpenCascade’s Python binding). Its dependencies include build123d, cadquery-ocp-novtk, ezdxf, shapely, matplotlib and playwright (for headless snapshot rendering). Every skill runs it with the same pinned uv command, so all of them share one installation and one warm build daemon.
  • The skills. Twelve SKILL.md files that teach the agent each workflow (listed below).
  • The plugin and viewer. In Claude Code, Codex and Cursor, the plugin also starts a local MCP server (cadgen mcp) and a CAD Viewer. Where the app can show views, models appear in the chat as cards you can orbit and select; Claude “can read what you selected and see what you see.” In a terminal, asking to see a model gives you a browser link instead.

A model is just a decorated Python function

This is the core contract from the CAD skill. A model is a plain script whose decorated function returns a build123d shape:

from cadgen import build123d as bd
from cadgen import step

WIDTH = 40.0


@step(out="../STEP/bracket.step")
def bracket():
    body = bd.Box(WIDTH, 20, 6)
    body.label = "bracket"
    return body


if __name__ == "__main__":
    bracket()

Running python src/bracket.py (through the pinned uv command) writes STEP/bracket.step. Stack @stl, @threemf or @glb on the same function and the mesh files are kept up to date on every run. One-off exports work from the command line:

cadgen stl build STEP/bracket.step STL/bracket.stl
cadgen 3mf build STEP/bracket.step 3MF/bracket.3mf
cadgen glb build STEP/bracket.step GLB/bracket.glb

Because the source is code, a design lives in git and a parameter change is a one-line diff. The agent measures in code too: read_step() returns native build123d geometry and read_scene() gives every face, edge and vertex a selector, so “is this hole 8 mm?” is a few lines of Python, not a guess from a screenshot.

The twelve skills

SkillWhat it does
CADCreates and edits models from text or images; STEP output, STL/3MF/GLB exports
step.partsSearches a hosted catalog of off-the-shelf STEP parts (screws, bearings, servos, connectors)
Engineering DrawingDimensioned PDF drawings: views, hidden lines, hole callouts, title block
DXF2D profiles, gaskets and cut layouts
URDF / SRDF / SDFRobot description files, MoveIt planning groups, simulator worlds
SendCutSendChecks DXF and STEP files before upload to the SendCutSend service
DfAM CheckMesh printability: wall thickness, overhangs, support volume, orientation
DFMSheet metal, CNC and injection-molding reviews, citing the rule behind each finding
G-codeSlices models with OrcaSlicer using your printer presets
Bambu LabsSends prints to Bambu Lab printers via Bambu Connect or Bambu Studio

The step.parts skill tells the agent to search the catalog “before creating simplified placeholder geometry”, and the DFM skill calls itself “a guided review skill, not an automatic feature-recognition or manufacturing certification engine.”

Quick start

Install uv first (uv --version to check). Then, for Claude Code, per the README:

claude plugin marketplace add earthtojake/text-to-cad#latest
claude plugin install text-to-cad@earthtojake

Restart Claude Code; the first start downloads the CAD runtime. Codex, Cursor, Grok Build and Gemini each have their own one or two commands in the README. For any other agent that supports skills:

npx skills add earthtojake/text-to-cad#latest

Install the plugin or the skills in an app, not both. As the README warns, “two copies means every skill twice.” The #latest branch holds only released versions. To opt out of telemetry, run uvx cadgen telemetry off (or set DO_NOT_TRACK=1 for one process).

Hands-on test (October 9, 2026)

We ran text-to-cad’s runtime in a fresh python:3.12-bookworm container on a GitHub-hosted runner (x86_64, 2 CPUs, 8 GB RAM, no GPU) against commit 523ae21341a4, with telemetry off. We did not use an agent: the plan was to run the README’s own bracket model directly, measure the STEP file, export STL and 3MF, and render a headless snapshot. The verdict is partial: 1 of 6 steps passed, and the run stopped at step 2 after 9.2 seconds.

StepResultTime
Install uv (pip install uv)uv 0.12.242.4 s
cadgen --version and cadgen doctor via the skills’ pinned uvx commandRuntime downloaded and installed; kernel FAILED6.8 s (exit 4)
Build the README bracket to STEPSkipped—
Measure the saved STEPSkipped—
Export STL and 3MFSkipped—
Headless snapshot renderSkipped—

What worked. The download is quick. uv fetched the runtime, including the 64.3 MiB cadquery-ocp-novtk kernel wheel, 33.7 MiB of SciPy and Playwright, and reported “Installed 59 packages in 989ms”. cadgen --version printed cadgen 0.7.19, and cadgen doctor found Python 3.13.16 and a build daemon and confirmed that sharing was “off: set by DO_NOT_TRACK or CADGEN_TELEMETRY in this environment”.

What failed. The kernel check:

kernel   FAILED — ImportError: libGL.so.1: cannot open shared object file: No such file or directory

The OpenCascade binding needs the system OpenGL library even in its “novtk” build, and a slim Debian image doesn’t have it. Without the kernel, nothing else can run: no model, no STEP, no export. The README covers a similar kernel-load failure on Windows (Smart App Control), but not this one on Linux. On Debian and Ubuntu, libGL.so.1 comes from the libgl1 package, so apt-get install libgl1 is the likely fix. We did not re-run with it, so we can’t confirm that it is the only missing piece. The good news is that cadgen doctor named the problem in under seven seconds instead of failing halfway through a build.

What this does not tell you. On a normal macOS or Linux desktop, OpenGL is almost always installed, so most users won’t hit this. Our run says nothing about how good the generated parts are, how well the viewer works, or how many tokens a real design takes. It does tell you that a Docker image, CI job or headless cloud agent needs one extra system package that isn’t documented.

Community reactions

The Hacker News launch thread (May 1, 2026; 186 points, 48 comments) was friendly to the project and skeptical of the category.

  • Spatial reasoning is the bottleneck. One commenter concluded that “LLMs are still very weak at spatial reasoning compared to diffusion models”, and pointed to Zoo as a company that “went to extreme lengths on this.” Another, who had built a blueprint-to-B-rep tool with Codex, agreed: “the damn thing has really no idea where things are in space.”
  • Hobbyists versus professionals. A skeptical reply argued that “there is a niche where text-to-CAD is good: hobby users who don’t want invest in learning a CAD software UI. For professionals, where results have dollar values, there needs to be a much deeper understanding of the problem domain.”
  • Benchmarks. One commenter wrote that “without benchmarks and/or a whole suite of non-cherrypicked examples, this means nothing.” The author replied that he was “working on benchmarks at the moment” and later said basic benchmarks had been added.
  • Practical tips. Several users got better results by having the agent render PNGs from several angles while iterating, a loop text-to-cad builds in through its snapshot command. One noted that Opus 4.7 on CAD work “uses up tokens like crazy.”

The issue tracker shows the pace: 80 releases in under six months, and now-closed bugs such as broken STL meshes from a valid teacup (#555), a hole through a curved wall (#433) and a Codex viewer timeout (#506).

Honest limitations

  • The model is still the weak link. text-to-cad gives the agent better tools; it doesn’t give it a sense of space. The author calls the planning text in the skills a “stop gap.” Expect simple brackets, enclosures and adapters to work, and complex assemblies to need several rounds of correction.
  • Undocumented Linux system dependency. As our test showed, a minimal Linux container can’t load the kernel without libGL.so.1.
  • Windows Smart App Control blocks the kernel. The README says the OCP wheel ships an unsigned native module, so on a fresh Windows 11 install with Smart App Control on “every cadgen command and import build123d fails.” The fixes are to turn Smart App Control off (it can only be turned back on by reinstalling Windows) or to use WSL.
  • Telemetry by default. It is anonymous, documented in detail, and never includes files, paths or prompts, but it is opt-out, not opt-in. A version check also contacts api.texttocad.dev once a day unless you set CADGEN_UPDATE_CHECK=0.
  • A fast-moving pin. Each skill pins an exact cadgen version, and the CAD skill warns that “an unmigrated model silently loses kinematics, materials and animation.” Update the plugin and skills together.
  • One main maintainer, who calls it “a fun open source tool” rather than a business.
  • Not a certification tool. The DFM and printability checks report measurements and cited rules. They don’t replace a machinist’s or a manufacturer’s review.

When to use text-to-cad, and what to pick instead

  • Use text-to-cad if you already work in Claude Code, Codex or Cursor and want printable or machinable parts as code: enclosures, mounts, adapters, robot links with matching URDF files.
  • Write build123d or CadQuery yourself if you want full control; it is the same open stack.
  • Use OpenSCAD with a general assistant for quick shapes where a mesh is enough.
  • Look at Zoo for a commercial text-to-CAD product with its own kernel.
  • Stay in Onshape, Fusion or SolidWorks for professional work with tolerances, assemblies and change control.

FAQ

Is text-to-cad free?

Yes. The repository and the cadgen package are MIT-licensed. You pay only for the agent you run it with (a Claude, ChatGPT or other subscription or API usage). Fabrication services such as SendCutSend charge for parts as usual.

Which agents does text-to-cad support?

The README lists plugins for Claude Code, Claude Desktop (as an MCP server), Codex, Cursor, Grok Build and Gemini. Any other agent that supports the skills format can install the skills with npx skills add earthtojake/text-to-cad#latest, without the in-chat viewer.

What file formats does it produce?

STEP is the main output. It also exports STL, 3MF and GLB meshes, 2D DXF drawings, dimensioned PDF engineering drawings, sliced G-code (via OrcaSlicer) and robot description files (URDF, SRDF, SDF).

Does text-to-cad work in Docker or CI?

It can, but not out of the box on a slim image. In our October 9, 2026 test on python:3.12-bookworm, the CAD kernel failed to load because libGL.so.1 was missing. Installing the system OpenGL library (libgl1 on Debian and Ubuntu) is the likely fix; we did not verify it. Snapshot rendering also needs a headless Chromium and its system libraries, which cadgen offers to install when it runs as root on Linux with apt.

Does text-to-cad send my designs anywhere?

No. Per the README, telemetry is “Never file names, paths, contents or prompts.” Your prompts do go to your agent’s model provider.

Verdict

text-to-cad is the best-built bridge between coding agents and real CAD we have seen: STEP from a proper kernel, models and checks as code, and a skill for each step from part catalog to printer. The agent’s spatial reasoning still sets the ceiling; the tooling raises the floor. If you print or machine parts and already live in Claude Code or Codex, install it and start with something simple. If you plan to run it on a server, add libgl1 to your image first.

Sources