# Vendor lock-in is dead: your CAD files are finally free

- Link: https://opensourcecad.nl/en/vendor-lock-in-is-dead-your-cad-files-are-finally-free/
- Published: 2026-11-06T21:39:11+01:00
- Author: Marijn van den Heuvel

_This is the English reading version of the Dutch news item [Vendor lock-in is dood: je CAD-bestanden zijn eindelijk vrij](https://opensourcecad.nl/tools/vendor-lock-in-is-dood-je-cad-bestanden-zijn-eindelijk-vrij/)._

![Dutchman logo: a small sailboat with a green and white flag.](https://opensourcecad.
nl/wp-content/uploads/2026/11/dutchman-logo-1.png)

Every CAD user knows it. You work in Fusion 360, SolidWorks or Inventor for years.
Your files are `.f3d`, `.sldprt`, `.ipt`. And when you want to switch packages, 
you lose exactly what makes your model _smart_: the feature history, the constraints,
the sketches and the relations. All you can get out is dead geometry, as STEP or
IGES. That is vendor lock-in in its purest form.

Vendors have no interest in open formats: their business model runs on subscriptions,
not on interoperability. But over the past years a quiet breakthrough has happened
in the open-source world. Two projects break the wall down: cadmpeg and Dutchman.

## cadmpeg: the engine under the bonnet

cadmpeg is not a CAD program. It is a conversion engine, open source and written
in Rust, that does three things.

 * It unpacks the containers: a `.f3d`, `.iam` or `.FCStd` is really a zip-like 
   archive.
 * It reads the geometry and the feature data out byte by byte, without the vendor’s
   SDK and without hacked code.
 * It puts everything into one common language, out of which STEP, Parasolid and
   other formats come out again.

cadmpeg only uses files the makers own themselves, plus public documentation. No
vendor code or vendor documents.

cadmpeg reads Fusion 360 (including the feature history), Inventor, SolidWorks (
the geometry), FreeCAD (nearly complete), CATIA, Creo View, ACIS, STEP and Rhino.
The `.prt` files from NX and Creo do open, but they do not yield geometry yet.

You can simply use it from the command line:

    ```wp-block-code
    cadmpeg convert design.f3d -f step -o design.step
    ```

## Dutchman: from dead shape to editable model

Dutchman sits on top of cadmpeg. It takes the data cadmpeg reads and translates 
the features into SolidCraft, a new open parametric kernel. The result is an `.sc`
file you open with editable sketches, constraints, extrudes, fillets, joints and
assemblies.

What makes Dutchman special:

 * The feature history comes along. An extrude from Fusion becomes an extrude in
   SolidCraft, a sketch stays a sketch.
 * An assembly comes in the way it last looked. A robot arm that was folded stays
   folded, and does not stretch out.
 * You pick the level yourself: Fast (shape only), Standard (history, sketches and
   joints within your memory) or Full (everything that can be carried over). You
   see in advance how much memory and time it takes.
 * You get a report per file: what did come through, what did not, and why not.
 * It comes as a desktop app, as a command line and as an MCP server for AI. Windows,
   Mac and Linux, and the Windows installer works without administrator rights.

Dutchman reads Fusion (`.f3d`/`.f3z`), Inventor (`.ipt`/`.iam`), SolidWorks (`.sldprt`/`.
sldasm`) and FreeCAD (`.FCStd`), plus CATIA, Creo View, ACIS and STEP.

## Who builds on it: SolidCraft and Mitcad

### SolidCraft: the open kernel Dutchman writes to

SolidCraft is the parametric kernel Dutchman drives: fully open, written in Rust,
with sketches and constraints, features on a timeline and assemblies with working
joints. It runs as a desktop app (Windows, Mac, Linux), in the browser and as a 
command line and MCP server for AI.

SolidCraft itself opens its own `.sc` designs, STEP, IGES, 3MF, STL, OBJ and glTF,
and it exports URDF among other things. Native files such as `.f3d` or `.sldprt`
are not in that list.

And that is exactly where the Dutchman script comes in: with it you open far more
in SolidCraft. Fusion, Inventor, SolidWorks, FreeCAD, CATIA, Creo View and ACIS 
come in through Dutchman, with their feature history where that is possible. Dutchman
delivers the `.sc` files, SolidCraft is the environment where you edit them further.

### Mitcad: a complete CAD app that uses cadmpeg

Mitcad is a full desktop CAD application (Windows, Linux, Mac, MIT licence) that
uses cadmpeg as its import engine. What you can already open in it:

 * FreeCAD `.FCStd`
 * Fusion `.f3d`
 * SolidCraft `.sc`, so through the whole chain: Fusion, cadmpeg, Dutchman, SolidCraft,
   Mitcad
 * Inventor `.ipt`
 * IFC and Revit `.rvt`: building models with their levels and elements
 * DWG: with 3D solids and blocks

Mitcad shows that an open-source CAD app can already handle production work: sketches,
timeline, assemblies, rendering and sending straight to a slicer (Bambu Studio, 
OrcaSlicer, PrusaSlicer and UltiMaker Cura).

## The whole chain at a glance

    ```wp-block-code
    Your .f3d / .ipt / .sldprt
            ↓
       cadmpeg     reads the file and translates it into one common language
            ↓
       Dutchman    turns the features into SolidCraft
            ↓
       SolidCraft  .sc file with an editable history
            ↓
       Edit in SolidCraft or Mitcad
    ```

## Where AI takes the threshold away

These tools are command-line programs and libraries, exactly what an AI agent is
good at. You can already ask an AI assistant: _“Convert my Fusion folder to SolidCraft
files, keep the feature history, and give me a report of what did not come through.”_

Dutchman has an MCP server that does exactly this, cadmpeg works in scripts and 
Mitcad can process batches. So you do not have to operate the tools yourself, you
let them work for you.

Say you have fifty `.f3d` files from an old client. You start Dutchman, point it
at the folder, pick “Standard” and let the AI assistant run the batch. You get `.
sc` files with a report per file. Whatever could not come over is listed in it.

## What does not work yet

 * NX and Creo `.prt`: they open, but do not yield geometry yet. Work is in progress.
 * SolidWorks feature history: not yet, that waits for more support in cadmpeg.
 * Very large assemblies: memory stays the limit (Dutchman counts on 16 GB for three
   large 3D printers).
 * PDM and PLM data: version history, owners and revisions do not come along, only
   the CAD file itself.

## Want to try it yourself?

 * Download [Dutchman](https://github.com/dutchman-cad/dutchman/releases/latest)
   and convert a `.f3d` or `.ipt`.
 * Try [SolidCraft in the browser](https://solidcraft.io/app) with an `.sc` file.
 * Look at [cadmpeg](https://github.com/cadmpeg/cadmpeg) if you want to build your
   own chain.
 * Look at [Mitcad](https://mitcad.org/) and open an `.FCStd` or `.f3d`.

**My verdict:** vendor lock-in is no longer inevitable. cadmpeg reads the native
files, Dutchman turns them into an open kernel, SolidCraft is that kernel and Mitcad
is the complete app that uses the whole chain. Together they already give you the
freedom to move your designs with their intelligence intact, to software that is
yours. The files belong to you, and now you can actually get at them again.