VectorCraft: a pure-Rust vector editor with an agent-facing API

VectorCraft's editable illustration model

VectorCraft addresses the creation and editing of scalable illustrations, icons, posters, type-based artwork, and compositions built from paths, shapes, fills, and live effects. Its intended users include artists familiar with tools such as the Pen, Direct Selection, Pathfinder, Appearance, Swatches, Layers, and Smart Guides. The project deliberately follows Adobe Illustrator's familiar layout rather than inventing an unrelated interface. That choice reduces the conceptual adjustment for Illustrator users, although the README describes VectorCraft as a clean-room reimplementation, not as a compatibility guarantee.

The `examples/` directory indicates that objects remain editable after composition. `examples/neon-drive.vectorcraft` uses Pathfinder operations, a live Outer Glow, a grid, and clipping masks. `examples/perspective-city.vectorcraft` places artwork on planes of a two-point perspective grid while retaining editability. Other examples demonstrate radial repeats, envelope distortion, gradient meshes, and blends with editable spines. These are document-level features rather than flattened visual effects, which matters to users who need to adjust source geometry after an illustration has been composed.

VectorCraft serves two overlapping groups. Artists need a graphical editor with direct manipulation, panels, paths, and type. Software builders may use its command API or MCP server to have agents create and change illustrations. The README says every piece presented under "Made in VectorCraft" was produced through the command API and exported by VectorCraft's own renderer. Automation therefore appears to be part of the product architecture rather than an incidental integration.

Inside the Rust workspace and document pipeline

Based on the repository layout and `Cargo.toml`, VectorCraft is divided into focused Rust crates rather than being a single application binary. Geometry, color, path operations, brushes, tracing, text, effects, 3D, rendering, SVG, PDF, document formats, tools, the editing engine, `egui` UI, MCP, plugins, CAD, EPS, and metafile handling each have a named crate. This separation places document operations below the graphical interface and creates boundaries that can be shared by applications, CLI code, and agent integrations.

The workspace names `apps/vectorcraft` and `apps/vectorcraft-cli` among its default members. The README confirms that VectorCraft exposes a command API through its MCP server, while the example directory contains both native `.vectorcraft` documents and an exported `.svg` file. Together, those details support a pipeline in which commands create or change a document, the document model retains editable objects and effects, and a renderer produces visible or exported output. The README does not publish the complete internal call sequence, so this is an architectural reading rather than a formal API description.

Rendering and file concerns are separated into crates such as `vectorcraft-render`, `vectorcraft-svg`, `vectorcraft-pdf`, `vectorcraft-format`, `vectorcraft-eps`, and `vectorcraft-metafile`. This arrangement keeps the editing engine distinct from particular formats. It also creates a broad dependency surface. `Cargo.toml` pins several `craft-libs` Git revisions for PDF, printing, and UI dependencies, while `Cargo.lock` records the workspace resolution. Integrators who require reproducible source builds need to preserve that exact dependency state.

Live effects, paths, and perspective editing

VectorCraft's strongest documented capability set is its support for editable, non-destructive illustration features. The `feature-sheet.vectorcraft` file names Pathfinder, Gradient Mesh, radial Repeat, and Envelope Distort. The `ribbons.vectorcraft` example contains three live blend ribbons with key paths, while the screenshots show objects listed in the Layers panel and selected paths with control points. This differs from exporting a static image and editing only its resulting path data because VectorCraft presents live properties associated with source objects.

Path creation and correction receive first-class interface treatment. The Direct Selection tool exposes Bézier anchors and handles, and the contextual task bar changes around the operation. Pathfinder is described as producing exact booleans, including a crescent formed from paths. Perspective Selection adds a plane-switching widget, allowing artwork attached to a perspective plane to remain editable. These mechanisms are relevant to technical illustration and poster work, but the README does not enumerate every available tool or document all edge cases.

Browser delivery through WebAssembly broadens the possible audience, although the README does not establish full parity between native and browser builds. It does not document plugin availability, browser file-system access, or restrictions in the WebAssembly implementation. A browser-only team should treat platform parity as something to verify rather than infer from the shared application name.

Downloading and opening the first VectorCraft document

The README links to `https://getartcraft.com/apps/vectorcraft` for VectorCraft downloads, but the visible Quick start and Downloads details do not include a confirmed install command, release artifact name, package manager instruction, checksum, or platform-specific setup procedure. This article therefore does not invent a command. The project page named by the README is the documented place to locate a build.

`Cargo.toml` provides useful source-build requirements. It declares workspace version `0.11.0`, Rust edition `2024`, and `rust-version = "1.95"`. It also uses Cargo resolver `3` and pinned Git revisions for dependencies from `https://github.com/storytold/craft-libs`. Those requirements do not by themselves document the complete build command or the availability of packages for each operating system.

For a first real use, the repository offers complete documents instead of a hypothetical exercise. A reader can obtain `examples/neon-drive.vectorcraft` and inspect editable type, a Pathfinder-generated sun, a live Outer Glow, grid artwork, and clipping masks. `examples/perspective-city.vectorcraft` covers plane switching and perspective attachment. For file interoperability review, `examples/dusk-poster.svg` provides an SVG artifact alongside the editable examples. Before opening them, verify that the downloaded application is version `v0.11.0` or record another exact version. The README does not specify compatibility behavior across releases.

Command API and MCP adoption constraints

The MCP server is VectorCraft's most distinctive choice for technical evaluation. It gives agents access to the same command API used to create the README's example artwork. This could support repeatable illustration generation without requiring an agent to return only a finished raster image. It also introduces a dependency on the stability and discoverability of a young API. The README does not publish tool names, parameter schemas, transport settings, authentication behavior, error contracts, or a complete agent session example.

That missing contract matters for production automation. An artist can evaluate much of the editor from its visible panels and tools, but an integrator needs predictable command identifiers, parameter definitions, version compatibility, and failure reporting. None of those details can be confirmed from the README. The `vectorcraft-mcp` crate establishes that the integration exists, not that every document operation can safely be called by an agent.

The recorded releases include `v0.11.0` on 2026-10-14, `v0.10.0` on 2026-10-12, and `v0.9.0` on 2026-10-11. The last push was on 2026-10-15, and the repository is not archived, so its maintenance signal is current. Recent work does not remove upgrade risk for a `0.x` application. Operators should pin the application and MCP components to the same release and retain copies of source documents before changing versions. The README does not provide a rollback procedure or document migration guarantee.

VectorCraft versus SVG-first editing

An SVG editor that operates directly on imported markup is the clearest alternative. Such a workflow can be standards-oriented and can keep XML as the primary editable artifact. VectorCraft takes a different approach. It maintains a native `.vectorcraft` document model with panels for appearance, layers, blends, clipping, perspective, and live effects. The repository includes `vectorcraft-svg` and an exported `.svg` example, showing that VectorCraft can participate in the SVG ecosystem. The README does not promise round-trip preservation of every SVG construct.

The difference matters when source assets are simple static diagrams. For basic path editing, an SVG-first tool may offer a smaller conceptual surface and make the XML file the obvious source of truth. VectorCraft becomes more relevant when an illustration depends on live Outer Glow, clipping masks, editable blend spines, radial repeats, envelope distortion, or perspective planes. Those are document behaviors that a flattened export is unlikely to preserve.

VectorCraft also supports native macOS, Windows, Linux, and FreeBSD applications, plus a WebAssembly build. A browser SVG editor may simplify deployment for a web-only workflow. VectorCraft's trade-off is a broader application and Rust workspace containing format, rendering, UI, effects, plugins, and agent subsystems. The relevant comparison is an editable native document model versus an SVG-first document workflow, not a native editor versus a flat image.

Licensing, upgrades, and operational review

The repository's `Cargo.toml`, README badge, and license files describe the project as `MIT OR Apache-2.0`, while the repository metadata names `Apache-2.0`. The project-level license declaration offers a choice between the two listed licenses. This article does not provide legal advice or decide which option applies to a particular distribution. Teams should review `LICENSE-MIT`, `LICENSE-APACHE`, and `NOTICE` together with their plans to package or redistribute VectorCraft and its dependencies.

Upgrade cost is tied to a pre-1.0 version. The current workspace version is `0.11.0`, and three `0.x` releases appear in the recorded release history. That version range warrants testing application startup, document opening, SVG or PDF output, and MCP commands before each upgrade. The README does not state a document compatibility policy, automatic migration behavior, or rollback guarantee, so users should preserve original files before opening them with a newer build.

Build complexity also warrants attention. The workspace targets Rust `1.95`, uses edition `2024`, includes many local crates, and pins external `craft-libs` revisions. A vendor directory exists, but the README does not document an offline build procedure. For an adoption review, pin `v0.11.0`, preserve the dependency state recorded in `Cargo.lock`, and open representative `.vectorcraft` and `.svg` files before allowing an agent to modify production artwork.

Editorial conclusion

VectorCraft fits artists who want an Illustrator-style editor and builders who intend to create or modify vector documents through its command API or MCP server. It is a poor choice when predictable long-term releases, complete setup instructions, or documented production automation are prerequisites. Evaluate `v0.11.0` first, then verify installation on the target platform, interoperability with existing `.vectorcraft` and `.svg` files, and the exact MCP operations required by the agent.

Frequently asked questions

Official sources

1. License: Apache-2.0
2. Project website
3. README
4. Releases
5. storytold/vectorcraft on GitHub