Skip to content
mitcadPublic

About

Free, open-source parametric 3D CAD for Windows, Linux and macOS. Imports many formats with their feature timeline.

Topics

Resources

Stars

299 stars

Watchers

5 watching

Forks

Repository files navigation

MitCad

MitCad is an open-source parametric desktop CAD application. It runs on Windows, Linux and macOS (Apple Silicon, macOS 14.4 or newer). Its license is the MIT license.

  • Parametric modeling with a history. You draw sketches with constraints and dimensions. Features go on a timeline. Parameters hold expressions. When you change a dimension or edit a feature, MitCad rebuilds the model.
  • Visual workflow. The window has a tabbed toolbar, command panels with a live preview and drag handles, the Browser, the Timeline and a command search.
  • Many CAD formats. FreeCAD, .f3d, SolidCraft and .ipt files open with their history. IFC and .rvt building models open with their storeys and elements. DWG drawings open with their 3D solids and blocks, .3dm models with their polysurfaces, meshes and blocks. MitCad imports and exports STEP, IGES, BRep, STL, OBJ, DXF and 3MF, imports SVG, and exports USDZ, web pages and drawings (PDF, SVG, DXF, DWG). The full table is in the user guide: File formats.
  • 3D printing. MitCad sends bodies directly to a slicer (Bambu Studio, OrcaSlicer, PrusaSlicer, UltiMaker Cura).

How to install and use MitCad: the user guide. Website: mitcad.org. Downloads: the releases.

A pillow block modeled in MitCad from an empty design, then a dimension changed: watch the demo on mitcad.org

Sketch mode: a fully constrained profile with driving dimensions and the sketch palette Editing an extrude: the command panel, drag handles and parameter labels, the timeline rolled back The rendered view: the assembly path traced with soft shadows inside the application
Sketch. MitCad solves constraints and driving dimensions as you draw. Edit. Roll back the timeline and change a feature. The model follows. Render. A path-traced view of the design, in the window.

Why

The world did not have a CAD application that is easy to use, imports many file formats and also runs on Linux. MitCad was started to be that application. It is free to use, change and share under the MIT license.

If a file does not import correctly, please open an issue.

Status

MitCad is under active development. Each release has a Windows installer, a Linux AppImage and a macOS disk image. Solid modeling, sketches, assemblies with joints that move their components, analysis, the file formats of the user guide and the version history of projects work.

Known gaps: direct modeling without a history, and some loft combinations.

Updates

Once a day, MitCad checks for a signed release and offers to install it (the Windows installation, a per-user AppImage, the macOS application). The user or an administrator can set the checks to off (docs/updates.md).

Building

MitCad is C++17 (Qt 6 Widgets, Open CASCADE Technology) and Rust (the model, the solver and the file import), built with CMake and Ninja; Corrosion builds the Rust crates and CXX bridges the two languages. Versions used in development: Qt 6.12 LTS, OCCT 8.0.1 (built by vcpkg with a few patches of MitCad's that speed up booleans and the shape checker on faces with many edges, let fillets run over faces narrower than they are, fix other failures and crashes of the fillet, and make an allocation that fails throw instead of crashing: third_party/vcpkg-ports), the Rust toolchain pinned in rust-toolchain.toml.

The configure presets in CMakePresets.json (linux-debug, linux-release, macos-debug, macos-release, windows-release; no Windows Debug build, as the render worker links release builds of its libraries) take vcpkg and Qt from the environment variables VCPKG_ROOT and QT_ROOT_DIR. The setup scripts below write a local CMakeUserPresets.json (not under version control) with a dev preset that sets them.

Build and test in an isolated environment (dependency build scripts run third-party code): docs/development.md.

Linux

Requirements: GCC 13+ or Clang, CMake 3.25+, Ninja, Rust, vcpkg and Qt 6.8+. On Ubuntu 24.04 the scripts install everything with pinned versions:

sudo tools/dev-env/install-packages.sh
tools/dev-env/setup-user.sh
cmake --preset dev && cmake --build --preset dev && ctest --preset dev

The first configure builds OCCT and the renderer's libraries with vcpkg (about 30 minutes). The application is build/dev/app/mitcad; use a release build (linux-release) for performance measurements. Packaging as an AppImage: docs/development.md.

Every build has the rendered view (a prototype with Cycles on the CPU, or an NVIDIA GPU with Cycles' CUDA device on Linux and Windows, Metal on macOS): the setup scripts run tools/dev-env/build-cycles.sh --cuda (build-cycles.ps1 -Cuda on Windows, build-cycles-macos.sh on macOS) once, which builds Cycles, its GPU kernels and Open Image Denoise from pinned sources outside the build folders (docs/rendering.md); MITCAD_RENDER_CUDA=0 leaves out the CUDA kernels' build on a development machine. Without the prefix the configure stops and names the script. The renderer is the executable mitcad-render next to mitcad (only it links the renderer's libraries), and View › Visual Style › Rendered appears whenever it is there, with View › Render Environment for the design's light (with lights of one's own), background, ground and exposure, and Render Image (and mitcad-cli render) for a final image file at a chosen size and quality; the AppImage, the Windows installer and the macOS bundle include it.

Windows

Requirements: Visual Studio 2022 or newer with the C++ desktop tools. setup-windows.ps1 installs Git, CMake, Ninja, ccache, Rust, Python, NSIS, cargo-deny, vcpkg and Qt (run it as an administrator), builds the renderer's libraries (build-cycles.ps1 -Cuda) and writes CMakeUserPresets.json; msvc.cmd runs a command in the MSVC environment:

powershell -ExecutionPolicy Bypass -File tools\dev-env\setup-windows.ps1 -Repo <checkout>
tools\dev-env\msvc.cmd cmake --preset dev
tools\dev-env\msvc.cmd cmake --build --preset dev
tools\dev-env\msvc.cmd ctest --preset dev

The application is build\dev\mitcad.exe (with Qt's bin on PATH) and needs OpenGL 2.1+. Without a GPU, build Mesa's llvmpipe with tools/dev-env/setup-mesa-windows.ps1 and configure with -DMITCAD_MESA_DIR=<dir>/bin (docs/development.md).

macOS

Requirements: Apple Silicon, macOS 14.4 or newer, the Xcode Command Line Tools and OpenGL 4.1 core (deprecated by Apple but present). In the build VM, setup-macos.sh installs CMake, Ninja, Rust, cargo-deny, vcpkg and Qt in the user's home directory, builds the renderer's libraries (build-cycles-macos.sh) and writes CMakeUserPresets.json:

tools/dev-env/sync-to-mac.sh
ssh <user>@<guest> "~/src/mitcad/tools/dev-env/setup-macos.sh"
ssh <user>@<guest> "cd ~/src/mitcad && cmake --preset dev && cmake --build --preset dev && ctest --preset dev"

The application is build/dev/app/mitcad.app. Packaging as a disk image: docs/development.md. macOS uses the same Qt interface as Linux and Windows; what stays native there (the Metal renderer, the system menu bar, the Settings window, system keys, trackpad navigation) and the macOS release check: macOS with the shared Qt UI. The AppKit frontend is paused and not built (native macOS UI).

Tests

tools/check-all.sh

runs the warning-free build, cargo fmt/clippy, dependency checks, and the ctests, corpus tests and UI tests (on a hidden Xvfb display) whose sources changed; tools/check-all.sh --full, the check before a release build, runs every test. Details, the Windows and macOS tests and the corpus setup: docs/development.md.

Repository layout

Directory Contents
core/model Rust model: document, timeline, features, sketches, naming, recompute, design file, JSON API (commands.md)
core/solver 2D sketch constraint solver
core/vec3 The [f64; 3] helpers shared by the model, the solver and the readers
core/f3d, core/f3d-design, core/f3d-decode, core/f3d-file, core/f3d-names, core/asm, core/dump, core/freecad, core/import, core/zip .f3d and FreeCAD readers (the ASM B-rep reader in core/asm, the dump IR in core/dump) and the history import
core/expr, core/print-keys Parameter expressions with units; the print settings' key map (both re-exported by the model)
core/ipt .ipt reader: compound file, property sets, segments, the bodies
core/solidcraft .sc and .solidcraft reader: the JSON design or its container, upgraded to one format; a .sc file only by its format key
core/3dm .3dm reader: the archive's chunks, layers, blocks and objects, and their conversion to the neutral B-rep model
core/dxf, core/3mf, core/usdz DXF, 3MF and USDZ
core/vcs, core/update Version history in git; automatic updates
core/ffi, core/cpp CXX bridges between Rust and C++
core/ffi-staticlib The bridges' static library that the application links
geometry C++ facade over OCCT
app Qt application (app/COMMANDS.md)
tools mitcad-cli, UI tests, dev environment scripts, FreeCAD export macros, macOS packaging
docs Architecture, development, user guide, updates, rendering, UI conventions
third_party Third-party files with their own licenses

Contributions

For the time being, we don't merge pull requests in this repository. Changes come in as a continuous stream of commits, and our development pipeline works best when they all flow in one direction. It is shaped like a tree: changes enter at its outer edges and converge, stage by stage, into a release. This GitHub repository sits at the trunk, where only finished releases arrive, one snapshot commit each. We intend to develop this further, but to keep the current pace, every change has to go through that pipeline for now. A pull request is therefore closed, and its change may be taken over internally. Issues are welcome and are the way to propose a change; a fix can be included in the issue as a diff.

AI agent policy

Issues made entirely by an AI agent are welcome, with these conditions:

  • An agent that writes issues (or a fix in one) uses at least Claude Opus 5.5 or GPT-6.1 Sol, with medium reasoning effort. High reasoning effort is preferred. Lighter models and lower effort levels are not accepted for this work.
  • Before writing an issue, the agent finds the code the issue concerns and refers to it in the issue (files, functions, the current behavior). This confirms that it has understood the context and the target correctly; an issue written without looking at the code is not accepted.

FAQ

Can RTX cards render faster? Can MitCad use OptiX?

MitCad does not ship OptiX, but you can build it for your own machine. The renderer can use the ray tracing cores of NVIDIA's RTX cards only through NVIDIA OptiX, and the OptiX license does not fit open source software. The OptiX SDK headers would be compiled into MitCad's renderer. NVIDIA's license permits the distribution of such a program only in binary form, only for NVIDIA hardware, and only when an enforceable agreement binds every recipient to NVIDIA's terms. Open source software that anyone can download, build, change and pass on cannot meet those terms. Thus MitCad's downloads have no OptiX: NVIDIA cards render with Cycles' CUDA device, which needs no such terms but does not use the RT cores, so RTX cards render slower than they could (docs/rendering.md).

With the OptiX SDK that you download from NVIDIA yourself, under its license, you can build an OptiX render worker for your own machine and pick it in Preferences › Display › Render worker; the shipped worker stays as the fallback. The build is for your own use: passing it on is between you and NVIDIA's license (Building an OptiX worker yourself).

License

MIT (LICENSE). Qt and OCCT are LGPL and linked dynamically. License policy: docs/development.md.

Model Context Protocol

mitcad-cli mcp --workspace /absolute/path/to/designs starts a headless MCP server over stdio for a local AI client. The server can make and open documents, run native modeling commands and queries, save editable .mitcad files, and export geometry inside the workspace. Add --read-only to inspect existing designs. mitcad-cli mcp --connect connects an agent to the open desktop application instead. Client setup, a modeling example, the error rules and the current limits: docs/mcp.md.

About

Free, open-source parametric 3D CAD for Windows, Linux and macOS. Imports many formats with their feature timeline.

Topics

Resources

Stars

299 stars

Watchers

5 watching

Forks

Releases

Packages

Contributors

Languages