draftcraft

Open-source CAD and drafting in pure Rust — with the ribbon you know from AutoCAD on Windows, on every desktop.

[!NOTE] DraftCraft™ was RustDraft. The program is RustDraft by SkryxDev, built on CADCraft; the DraftCraft name and logo are WithShalom Studios’ brand, used here by agreement (docs/brand/LICENSE-brand.txt). The rename is under way: the installers, the app bundle, the program files and the settings folder still carry the name RustDraft for now.

DraftCraft with the Home tab of the ribbon and the sample drawing: a mounting bracket with dimensions, a section view and a title block

DraftCraft™ is a 2D CAD application for drafting, dimensioning and plotting drawings, written from the ground up in Rust. It opens and saves DWG and DXF files, speaks AutoCAD’s command names and prompts at its command line, and puts everything in a Windows-style ribbon — the same on macOS, Windows and Linux, so you find the tools where you expect them on any computer. It is also built to be driven by AI agents: an MCP server, a JSON control channel and a headless CLI reach the same commands as the ribbon.

Features

The ribbon — Home, Insert, Annotate, Parametric, View, Manage, Output, Add-ins, Collaborate and Extra Tools, with large, small and split buttons. Circle ▾, Arc ▾, Trim ▾, Fillet ▾, Array ▾ … open a drop-down of their methods; panels shrink and fold into a single button from the right when the window is narrow.
Familiar layout — application menu, Quick Access Toolbar, file tabs, a floating command line, [-][Top][2D Wireframe] viewport label, ViewCube with navigation bar, Model / layout tabs and drafting toggles on the status bar.
Command line like AutoCAD’s — the same command names and aliases, prompts with clickable keywords, AutoComplete, @dx,dy, @d<a, #x,y, direct distance entry, transparent commands and scripts.
Draw and modify — LINE, PLINE, CIRCLE, ARC, RECTANG, POLYGON, ELLIPSE, SPLINE, TEXT, MTEXT and more; MOVE, COPY, ROTATE, SCALE, MIRROR, STRETCH, OFFSET, TRIM, EXTEND, FILLET, CHAMFER, ARRAY, grips.
Conic arcs — CONIC draws an exact ellipse, parabola or hyperbola arc from its end points, the apex where its tangents meet and a rho value (or a point it passes through): the soft corners of a phone in plan view, for example. It is saved as a rational SPLINE, so it opens as a normal spline in AutoCAD and any other DXF or DWG program.
Precision — object snaps (endpoint, midpoint, center, intersection, tangent, perpendicular…), polar tracking, ortho, grid snap.
Layers and properties — the layer list and colour / linetype / lineweight lists right on the ribbon, the Layer Properties Manager and a Properties palette that edits any object.
Annotation — every DIM command with dimension styles, associative dimensions, multileaders, tables, TrueType fonts and right-to-left text.
Hatches and blocks — pattern, solid and gradient fills, blocks with attributes.
Parametric — geometric and dimensional constraints, auto-constrain, parameters with expressions.
Layouts and plotting — paper-space layouts with viewports, page setups, PDF plotting, SVG and PNG export.
Files — DWG and DXF reading and writing.
AutoLISP — load and run LISP routines, scripts and alias files.
18 interface languages, Italian included, switched live.

Screenshots

Split buttons list every method; Arc and Circle picture each one.

A selected line with its blue grips and the Properties palette on the right, with the Annotate tab of the ribbon

Selection grips and the Properties palette, with the Annotate tab.

Layout1: a paper sheet with a viewport showing the bracket drawing, ready to plot

A layout with a viewport onto the model, ready to plot.

Keyboard shortcuts

On Windows and Linux, Ctrl takes the place of ⌘.

Keys	Action
`⌘N` `⌘O` `⌘S`	New, open, save
`⇧⌘S`	Save as
`⌘P`	Plot
`⌘Z` `⇧⌘Z`	Undo, redo
`⌘X` `⌘C` `⌘V`	Cut, copy, paste
`⇧⌘C` `⇧⌘V`	Copy with base point, paste as block
`⌘A`	Select all
`⌘F`	Find and replace
`⌘1`	Properties palette
`⌘9`	Show or hide the command line
`F1`	Command reference
`F2`	Command history
`F3`	Object snap
`F7` `F8` `F9`	Grid, ortho, snap
`F10` `F11` `F12`	Polar tracking, object snap tracking, dynamic input
`Delete`	Erase the selection
`esc`	Cancel the command
`↩` or `space`	Repeat the last command

Typing works like in AutoCAD: start typing anywhere in the drawing and it goes to the command line.

line 0,0 @10,0 @0,5 c          a closed triangle
circle 5,2 1                    a circle
offset 0.25                     then pick the circle and a side
zoom e                          zoom to the drawing's extents

Install

Download the file for your system from the latest release:

System	File
macOS (Apple silicon)	`RustDraft-<version>-macos-arm64.dmg`
Windows x64	`RustDraft-<version>-windows-x86_64.zip`
Windows ARM64	`RustDraft-<version>-windows-arm64.zip`
Linux x64	`RustDraft-<version>-linux-x86_64.tar.gz`

macOS — open the DMG and drag RustDraft into Applications. The app is not notarized yet, so macOS blocks it the first time. Open it once, then go to System Settings › Privacy & Security and click Open Anyway — or run:

xattr -dr com.apple.quarantine /Applications/RustDraft.app

Windows — unzip the folder anywhere and run RustDraft.exe. The build is not signed, so SmartScreen may stop it the first time: click More info › Run anyway.

Linux — unpack the archive and run ./rustdraft. The share/ folder holds a desktop entry and the icons for your menu.

Every package also contains rustdraft-cli, the headless command-line tool and MCP server.

Updates — when DraftCraft starts it asks GitHub whether a newer release is out and, if there is one, asks whether you want it: Download opens the release page. Help › Check for Updates… checks at any time. That one request to api.github.com is all DraftCraft sends; set RUSTDRAFT_NO_UPDATE_CHECK=1 to turn it off.

Use it with AI agents

DraftCraft ships an MCP server. Add it to Claude Desktop, Claude Code or any MCP client, and the agent draws in the open DraftCraft window while you watch (on macOS it opens the app when needed):

{
  "mcpServers": {
    "rustdraft": {
      "command": "/Applications/RustDraft.app/Contents/MacOS/rustdraft-cli",
      "args": ["mcp", "--connect", "127.0.0.1:7982", "--launch"]
    }
  }
}

The agent types at the command line (command_line), runs any command with JSON parameters (execute), reads the drawing (inspect_drawing, query_entities, find_text) and looks at it (render, screenshot). rustdraft-cli mcp with no --connect works on its own, without a window.

The CLI also converts and renders drawings in scripts:

rustdraft-cli info drawing.dwg
rustdraft-cli convert drawing.dxf drawing.pdf
rustdraft-cli run --sample --script 'CIRCLE 22,3 1\n' --save out.dxf --export out.png

More: MCP · CLI · control channel · LISP, scripts and aliases · AutoLISP

Build from source

Requirements: Rust 1.95 or later. On Linux, also the development packages for X11/Wayland and fontconfig (pkg-config libxkbcommon-dev libwayland-dev libx11-dev libfontconfig1-dev on Debian/Ubuntu).

git clone https://github.com/SkryxDev/RustDraft.git
cd RustDraft
cargo run --release -p rustdraft -- --sample

--sample opens the sample drawing. To build the app and the CLI without running them:

cargo build --release -p rustdraft -p rustdraft-cli

The programs are written to target/release/ (rustdraft and rustdraft-cli). The interface fonts for Chinese, Japanese, Korean, Arabic, Thai and more come from the optional craft-fonts repository: clone it and set CRAFT_FONTS_DIR=/path/to/craft-fonts before building to embed them. Without it DraftCraft uses the fonts installed on your system.

The quality checks — formatting, clippy, tests, asset licences, crate layering and the web build — run with:

cargo xtask ci

Releases are built by the release workflow when a v* tag is pushed; see docs/releasing.md.

How it works

crates/
├── geom/          f64 geometry: arcs, bulges, splines, intersections, offsets
├── dxf/           DXF tag reader and writer
├── dwg/           DWG reading and writing
├── color/         colour index and true colour
├── doc/           the drawing database (copy-on-write entities, cheap undo)
├── fonts/         our own stroke font, TrueType and TEXT/MTEXT layout
├── render/        display lists, linetypes, hatches, dimensions, CPU raster
├── constraints/   geometric and dimensional constraint solver
├── io/            DXF/DWG mapping, SVG, PNG and PDF export
├── engine/        sessions, commands, command line and prompts, snaps, selection, undo
├── ui-egui/       the interface: ribbon, canvas, palettes, dialogs
└── mcp/           the MCP server
apps/
├── rustdraft/     the desktop app
├── rustdraft-cli/ the command-line tool
└── rustdraft-web/ a browser build (WebAssembly)

Everything is a command. The ribbon, menus, command line, scripts, the CLI, the control channel and MCP all run the same commands, defined once in crates/engine/src/cmd/.
The interface is a thin layer. Nothing below ui-egui knows about the GUI toolkit, and cargo xtask layers checks it, so the front end can be replaced.
It never panics on your data. Files, typed input and agent requests are treated as hostile; every command runs behind a guard that restores the drawing and reports an error instead of crashing.
Drawing happens on the GPU through wgpu (Metal, DirectX 12, Vulkan), with a CPU fallback.
No borrowed artwork. Every icon is drawn in code, and the hatch patterns, linetypes and drafting font are DraftCraft’s own definitions; ATTRIBUTION.md lists every asset file.

Settings, logs and autosaves live in ~/Library/Application Support/RustDraft on macOS, %APPDATA%\RustDraft on Windows and ~/.config/rustdraft on Linux.

Status

DraftCraft is young. 2D drafting, dimensioning, layouts and plotting work; 3D modelling is not there yet, and some object types that DWG/DXF files can contain can be lost on save. ROADMAP.md lists what works, what is missing and what comes next.

Found a bug?

Please open an issue with what you did, what you expected and what happened — a screenshot or the drawing helps a lot. The log file is in the logs folder of the settings directory above.

Pull requests are welcome too: fork the repository, make your change on a branch, run cargo xtask ci, and open a pull request.

License

DraftCraft is licensed under the MIT License or the Apache License 2.0, at your option. Third-party material is listed in NOTICE and ATTRIBUTION.md.

DraftCraft™ and the DraftCraft logo are trademarks of WithShalom Studios, who first made the name and the trademark claim. The licences above cover the code, not the name or the logo: you may fork and redistribute the code, but a modified version should not be presented as DraftCraft. Their terms are in docs/brand/LICENSE-brand.txt.

Credits

Made by SkryxDev. The DraftCraft™ name and logo are by WithShalom Studios.

DraftCraft is based on CADCraft by the ArtCraft Team and the CADCraft contributors, used under the same MIT OR Apache-2.0 licence; their copyright notice is kept in LICENSE-MIT and NOTICE. DraftCraft is an independent project: it is not made, sponsored or endorsed by them, and it is not affiliated with, sponsored by or endorsed by Autodesk, Inc. AutoCAD and DWG are trademarks of Autodesk, Inc., named here only to describe compatibility.

This site is open source. Improve this page.