ArtCraft Apps: Open Source Creative Suite in Rust
ArtCraft's Crafting Apps promise native Rust, local files and agent control. Here is what the project states, what it leaves out, and how to test it.

The pitch for a suite of open source creative tools usually breaks on one of two points: the apps are web wrappers that feel foreign on the desktop, or they are 'familiar' in screenshots and unusable with the files you already have. ArtCraft's Crafting Apps page makes specific claims about the first. It is silent on the second, and that gap matters for anyone considering it as a replacement for a proprietary toolchain.
The page does not cover file format support, maturity or the exact licences, so verify those before relying on the suite. The page does not describe the apps as 'Adobe compatible' in those words, so treat that framing as a hypothesis to test.
What the project actually claims
The page lists six principles shared by every app: open source, native not wrapped, familiar from day one, local files, agent-ready, and also available in the browser. Each one is a testable claim, which is more useful than a feature list.
- Open source: every line is on GitHub under permissive licenses (plural, so check each repository rather than assuming one licence covers the suite).
- Native: pure Rust compiled to desktop apps for macOS, Windows and Linux, with no Electron and no web views.
- Familiar: layouts, tools and shortcuts that working professionals already know.
- Local: everything runs on your own files, with no cloud round-trips.
- Agent-ready: a CLI, a JSON control channel or an MCP server for each app.
- Browser: twelve of the apps also compile to WebAssembly.
It says every Crafting App is written from scratch in Rust. That is a larger commitment than binding existing C++ libraries, and it shapes everything below.
Native Rust with no Electron or web views
'No Electron, no web views' is a concrete architectural statement. There is no embedded Chromium to ship, patch or keep in sync, and no JavaScript UI layer between the user and the document model. For teams that have to vet what runs on a workstation, a single compiled binary per platform is easier to reason about than a bundled browser runtime.
The cost is on the project's side. Writing rendering, text layout and file handling from scratch means the project owns every bug a mature library would have absorbed. The page gives no benchmarks, memory figures or startup times, so it does not show whether the native approach pays off in speed. Measure it on your own heaviest files before you take it as a given.
Agent-ready: CLI, JSON control channel, MCP
This is the most distinctive principle. The page says you can drive every app from a CLI, a JSON control channel or an MCP server, 'built for automation and AI agents'. For an engineering team, that turns a design tool into a scriptable component: batch jobs, CI checks on generated assets, or an agent that edits a document through a structured protocol rather than by simulating mouse clicks.
The page does not document command names, the JSON message schema or which MCP tools are exposed, so those are the first things to read in the repositories. Questions worth answering before you build on it:
- Does the control channel cover the same operations as the GUI, or a subset?
- Is the message schema versioned, so scripts survive upgrades?
- Can the apps run headless on a build server, or do they still expect a display?
Twelve apps in a browser tab
The page names the apps that also compile to WebAssembly: PhotoCraft, VectorCraft, LightCraft, PdfCraft, EffectCraft, DesignCraft, FigCraft, WordCraft, SoundCraft, DeckCraft, CADCraft and GridCraft. The names suggest the scope, covering raster, vector, PDF, documents, slides, spreadsheets-style grids, audio and CAD, but the page does not say how complete any individual app is, so do not judge from a name.
One Rust codebase targeting both native and WebAssembly is appealing, since it means one implementation to audit. The 'local files' principle is stated for the desktop apps, so if you plan to use the browser builds, check how they load and save files and whether anything leaves the machine.
Testing the 'Adobe compatible' claim
What the page supports is 'familiar': layouts, tools and shortcuts that working professionals already know. That is about muscle memory. It is not a statement about opening and saving the file formats your existing projects use, and the page doesn't mention any format at all.
If compatibility is your reason for looking, make it a short test rather than an assumption:
- Take three real files from your current workflow, including the ugliest one.
- Open each in the matching Craft app, then save and reopen it.
- Check layers, fonts, colour handling and effects against the original.
- Repeat the round trip through the CLI or control channel if automation is the goal.
Failures at step three are the real cost of switching, and no feature page will show them to you.
Where this does not fit, and what to watch
A project page tells you what the project promises, not how it holds up. The page does not cover release cadence, test coverage, plugin support or how the apps handle very large documents. A suite written entirely from scratch is also a suite where parity with decades-old proprietary software will be uneven, and you should expect to find gaps.
It is a poor fit if your pipeline depends on exact round-trip fidelity with a proprietary format, on a plugin ecosystem, or on a vendor support contract. It is a better fit where you value auditable code, local processing, and the ability to script tools from an agent. Read the licence file in each repository before adopting any of them, because 'permissive' is a category, not a single set of terms.
- #ArtCraft
- #Crafting Apps
- #MCP server
- #Open Source
- #Rust
- #WebAssembly


Comments