OpenPencil: an open-source Figma alternative with a CLI, MCP server and Vue SDK

What OpenPencil solves, and who it is actually for

Figma files are a de facto interchange format, and until recently there was no open tool that read them without going through Figma's servers. OpenPencil reads and writes .fig and .pen documents locally, and the same document model is exposed through a CLI rather than only through a canvas. That combination is the point: the editor is one consumer of the format, not the only one.

The audience is narrower than "designers who want a free Figma". It fits engineers who already have .fig files in a repository and want to inspect, lint, convert or diff them in CI. It fits teams building a workflow-specific editing surface on top of the Vue SDK. And it fits anyone wiring design files into an AI agent, because the repository ships both a CLI and an MCP server. A designer who only wants to draw rectangles gets a working editor, but the README's own status line says the project is in active development with rough edges, so that audience should expect movement.

The document pipeline behind the .fig support

The workspace layout shows the format handling is split into separate packages rather than one monolith: packages/fig, packages/pen, packages/kiwi, packages/scene-graph and packages/core. Kiwi is the binary serialisation layer Figma uses, so a .fig file is decoded into a scene graph, manipulated there, and re-encoded on write. The CLI, the Vue SDK and the desktop app all sit on that same scene graph, which is why `openpencil eval` can run Figma Plugin API code against a file on disk and write it back.

Two consequences follow. First, node identifiers are stable enough to address from a shell: the README's tree output shows ids like `0:46568` next to each frame, and `openpencil node design.fig --id 1:23` takes one directly. Second, layout is not a browser concern. Auto layout and CSS Grid run through Yoga compiled to WASM, so flex and grid behaviour is computed in the document model and is available headlessly. That is what makes `openpencil analyze spacing` meaningful on a file nobody has opened.

The AI layer is deliberately provider-agnostic. The README lists OpenRouter, Anthropic, OpenAI, Google AI, Z.ai, MiniMax and "compatible endpoints" as backends for the built-in chat, and the tool count is given as 90+ in the feature list and 100+ in the chat section. Those two numbers disagree in the same README, which is a small but real sign of how fast this area is moving.

Installing OpenPencil and running a first headless query

On macOS the README gives Homebrew as the install path. If you only want to look at the editor, the project also runs as a web app with no install.

brew install openpencil

For scripting, the CLI is a separate npm package and can be installed globally with npm or bun.

npm install -g @open-pencil/cli
# or: bun add -g @open-pencil/cli

With the CLI on your PATH, point it at any .fig file. The tree command prints an indented node tree with type, name and id for each entry, so you can confirm the file parsed before doing anything else.

openpencil tree design.fig
openpencil info design.fig

The first genuinely useful step past inspection is XPath, because it turns a design file into something you can assert on. The README's examples select frames by width, text nodes by name substring, and nodes by corner radius.

openpencil query design.fig "//FRAME[@width < 300]"
openpencil query design.fig "//TEXT[contains(@name, 'Button')]"

Every command accepts `--json`, which is the form you want in a script. Linting follows the same shape and supports presets and single rules.

openpencil lint design.fig --preset strict
openpencil lint design.fig --list-rules

If the desktop app is already running, drop the file argument entirely. The CLI connects over RPC and operates on the live canvas, which is how the README positions it for automation and agents.

Where OpenPencil is the wrong tool

The most obvious boundary is format fidelity. OpenPencil reads and writes native Figma files, but there is no compatibility statement in the README, no list of unsupported node types, and no documented round-trip guarantee. If your workflow depends on a .fig file surviving a trip through a third-party tool byte-for-byte, or on every Figma feature being represented, you are relying on something the documentation does not promise. Test on a copy before you point it at a file you care about.

The AI features are not self-contained. The built-in chat needs an external provider, and the README names the ones it supports; there is no local model path described. On a machine without network access or without a provider key, the assistant is inert. The image vectorization feature is in the same position: it requires Recraft or fal.ai.

Collaboration is P2P over WebRTC with no server and no account, which is a clean design for small sessions and a poor fit for anything that needs a durable shared document, access control, or a session that survives everyone closing their laptops. There is no server component to host, so there is nothing to configure and nothing to fall back on.

Finally, the project describes itself as in active development with rough edges. The version history shows 0.13.1, 0.13.2 and 0.14.0 within roughly two and a half months. For a tool whose value proposition is reading and writing a binary file format, that release cadence is a warning, not a selling point: pin a version if you script against it.

How it differs from Penpot and from Pencil

Penpot is the other well-known open-source design tool, and the difference is architectural rather than cosmetic. Penpot is a self-hosted web application with a server, a database and its own file format; you run infrastructure and your team works inside it. OpenPencil is a Tauri desktop binary of roughly 7 MB plus a browser build, with no server in the loop, and its file format is Figma's, not its own. If your requirement is "host our design tool on our own servers", Penpot is built for that and OpenPencil is not. If your requirement is "read the .fig files we already have, from a script", the reverse holds.

Pencil is a closer comparison and the one search queries keep pairing with OpenPencil. The README says OpenPencil opens "supported Pencil documents", which is a narrower claim than the .fig support and implies the .pen handling is a subset rather than full parity. Anyone migrating from Pencil should treat .pen support as the thing to verify first, not the headline feature.

The third alternative is not a design tool at all: doing the work by hand in Figma's own plugin sandbox. OpenPencil's `eval` command exposes the Figma Plugin API against a file on disk, which means existing plugin scripts have a plausible path to running outside the editor. That is a different kind of substitution, and for teams with a pile of internal Figma plugins it may matter more than the editor itself.

Licence, maintenance and what upgrades cost

The repository is MIT licensed, and the root package.json repeats that with `"license": "MIT"`. For most users that means you can embed the Vue SDK, ship a modified desktop build, or use the CLI inside a commercial pipeline without a copyleft obligation. The MIT text itself places no conditions on how you deploy the software, but it also offers no patent grant and no warranty, which is the standard trade. This is not legal advice; if you are embedding the SDK in a product, have counsel read the LICENSE file rather than a summary.

The last push to the default branch was on 2026-09-15, so the repository is being worked on. The most recent tagged release is v0.14.0 from 2026-08-11, with v0.13.2 on 2026-05-30 and v0.13.1 on 2026-05-29. Two things follow for upgrade cost. The project is pre-1.0, so minor version bumps can carry breaking changes; and the two 0.13.x releases one day apart suggest patches land quickly when something breaks.

The real upgrade cost is not the CLI binary, it is anything you have written against the scene graph or the SDK. The README does not document a deprecation policy for `eval` scripts or for the Vue composables, and the CHANGELOG is the only place that would tell you what moved. If you build on the CLI's JSON output or on SDK components, treat the CHANGELOG as a required read before every bump, and pin the version in package.json rather than tracking latest.

Editorial conclusion

Adopt OpenPencil if you need to read or write .fig files from a script, lint a design system from CI, or embed an editor through the Vue SDK. Do not adopt it if you need a frozen file format contract or assume the built-in AI works without an external provider key. Before committing, verify that your .fig files survive a round trip through `openpencil export -f fig` and back, and check the CHANGELOG for how often the file format changes between minor releases.

Frequently asked questions

Official sources

1. License: MIT
2. open-pencil/open-pencil on GitHub
3. Project website
4. README
5. Releases