# CADrs – native open source onshape clone in Rust and occt

> Source: <https://github.com/rvdende/cadrs>
> Published: 2026-10-17 08:28:50+00:00

**A parametric, feature-based CAD app written in Rust**, with a Bevy UI and an OpenCASCADE
modeling kernel. Its workflow follows Onshape's: sketch on a plane, constrain and dimension,
build parts from features, put them together in assemblies, and make drawings from them.

**Status: early and moving fast.** cadrs works through the Onshape Learning Center's CAD
Basics courses exercise by exercise, but it is not yet a finished tool. Expect rough edges,
and file formats that may still change.

- **Sketching** : lines, rectangles, circles, arcs, splines, Bézier curves, ellipses, polygons,
slots, points and text. Snapping and inference to points, midpoints, centres, intersections,
alignments and part edges. Geometric constraints and driving dimensions, with a
least-squares solver that keeps the sketch consistent while you drag. Trim, extend, split,
offset, mirror, patterns, and Use (project) of part edges.
- **Part Studios** : extrude, revolve, sweep, loft, fillet, chamfer, shell, draft, hole
(counterbore, countersink, tapped; ISO and ANSI tables), linear and circular patterns,
mirror, booleans, Transform, planes, mate connectors, thicken, fill and helix. Every feature
can be edited later, and the part rebuilds.
- **Assemblies** : instances, fastened, revolute, slider, cylindrical, planar and other mates,
a triad to move parts, mate connectors, exploded views and a bill of materials.
- **Drawings** : standard and projected views, sections, dimensions, annotations, callouts
and BOM tables.
- **More** : versions and history, derived parts and linked documents, a variable table and
expressions, measurement and mass properties, linear static simulation (FEA), a path-traced
renderer, PCB Studio with IDF import and export, and STEP, IGES and STL import and export.
- **Drag and drop** : drop SVG, EPS, PDF, DXF or DWG drawings onto a Part Studio or an open
sketch to get editable sketch curves, pictures to place them, and STEP, IGES or STL models to
import them (EPS and PDF need Ghostscript and Poppler installed).
- **Onshape import** : bring your own Onshape documents across with their feature history
instead of dead STEP geometry ([tools/onshape](https://github.com/rvdende/cadrs/blob/main/tools/onshape/README.md) ).

*From sketch to part to PCB, in one document. [Watch the 90-second demo](https://youtu.be/qT1FKZqUAxA).*

You need a stable Rust toolchain ([rustup](https://rustup.rs)), CMake and a C++ compiler.
The first build compiles OpenCASCADE from source, which takes several minutes; later builds
are incremental.

On Debian or Ubuntu, Bevy also needs these:

```
sudo apt install cmake g++ pkg-config libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
```

Then:

```
git clone https://github.com/rvdende/cadrs
cd cadrs
cargo run --release
```

On macOS, CMake from Homebrew (`brew install cmake`) and the Xcode command line tools
(`xcode-select --install`) are enough; it builds and runs natively on Apple Silicon (Metal).

Documents are stored in your platform's data folder (on Linux, `~/.local/share/cadrs/`).

A Windows build can be cross-compiled from Linux with MinGW:
`cargo build --release --target x86_64-pc-windows-gnu`.

The mouse and keys follow Onshape's: right-drag orbits, middle-drag pans, and the wheel zooms
toward the cursor. **Shift+S** starts a sketch, **Shift+E** an extrude, **N** views normal to
the sketch plane, **Shift+7** gives the isometric view, and **F** zooms to fit. **Shift+/**
(or Help › Keyboard shortcuts) lists the rest.

cadrs has an MCP server (Model Context Protocol), so an AI assistant on your machine (Claude
Code, Claude Desktop, Cursor, …) can drive the running app: create documents, draw sketches,
add and edit features, read back faces and edges, export STEP and take screenshots. Turn it on
in **Preferences › AI assistants (MCP)**; the app then serves Streamable HTTP on
`http://127.0.0.1:7680/mcp` (loopback only; the port is a preference). Every tool call runs
through the command layer, so the assistant's steps show in the feature list and undo like
your own.

The repository's `.mcp.json` registers the server with Claude Code for this project (approve
it with `/mcp` the first time; `claude mcp list` shows whether it is connected). Elsewhere,
`claude mcp add --transport http cadrs http://127.0.0.1:7680/mcp` does the same, and other
clients take the URL in their MCP settings.

The tools: `create_document`, `open_document` and `get_document`; `add_part_studio`;
`add_sketch` (rectangles, circles, polygons, lines and arcs on a default plane, a part face or
a Plane feature); `extrude`; `add_feature`, `edit_feature`, `get_feature` and `delete_feature`
for any feature type from JSON; `list_faces` and `list_edges` for the references fillets,
chamfers and sketches take; `import_step` and `export_step`; `screenshot`; `run_scenario` for
scripted UI steps; and `undo`. `crates/cadrs_mcp` is the server and the tools' schemas;
`crates/cadrs_app/src/mcp.rs` runs the calls on the app.

```
cargo test --workspace                    # all tests
cargo clippy --workspace --all-targets    # lints
cargo run -- --headless --scenario <name> # run a scripted scenario, saving screenshots
```

Scenarios (`scenarios/*.ron`) drive the real app with synthetic input and write PNGs to
`target/scenarios/<name>/`. The golden tests in `crates/cadrs/tests/golden.rs` compare them
with baselines kept on your machine (`tests/golden/`, not committed); the first run records
them, and `CADRS_BLESS=1` saves new ones.

| Crate | What it is | 
|---|---|
| `cadrs` | The binary: command-line flags, windowed or headless | 
| `cadrs_app` | The app's Bevy plugins: documents page, tabs, viewport, tools and dialogs | 
| `cadrs_ui` | A reusable Bevy widget library (theme, buttons, inputs, menus, dialogs, lists) | 
| `cadrs_core` | The document model, features, rebuild, commands and undo, persistence (no Bevy) | 
| `cadrs_sketch` | Sketch geometry, constraints, the solver, snapping and hit testing (no Bevy) | 
| `cadrs_kernel` | Our solid-modeling API over OpenCASCADE, with persistent face and edge names | 
| `cadrs_drawing` | Drawing views, projection and annotations | 
| `cadrs_fea` | Linear static finite-element analysis | 
| `cadrs_render` | A CPU path tracer for photorealistic renders | 
| `cadrs_idf` ,`cadrs_pcb` | IDF files and PCB boards | 
| `cadrs_onshape` | The Onshape document importer | 
| `cadrs_harness` | Scripted scenarios, synthetic input and screenshots | 
| `cadrs_mcp` | The MCP server through which AI assistants drive the app | 

[crates/cadrs_kernel/README.md](https://github.com/rvdende/cadrs/blob/main/crates/cadrs_kernel/README.md) describes the modeling layer:
the kernel API, persistent face and edge naming, and the OpenCASCADE backend. The notes in
`reference/onshape/` record how Onshape behaves, which is what cadrs is measured against.

Licensed under either of

- Apache License, Version 2.0 ([LICENSE-APACHE](https://github.com/rvdende/cadrs/blob/main/LICENSE-APACHE) or[http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0) )
- MIT license ([LICENSE-MIT](https://github.com/rvdende/cadrs/blob/main/LICENSE-MIT) or[http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT) )

at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in this work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Third-party parts keep their own licenses: the [Inter](https://rsms.me/inter/) font is under
the SIL Open Font License ([assets/fonts/OFL.txt](https://github.com/rvdende/cadrs/blob/main/assets/fonts/OFL.txt)), and
[OpenCASCADE](https://dev.opencascade.org/) under the LGPL 2.1 with the OCCT exception.

cadrs is an independent project. It is not affiliated with, endorsed by or sponsored by PTC or Onshape. Onshape is a trademark of PTC Inc. cadrs uses its own icons, font and branding.