The open-source alternative to Figma
Figma is excellent and it isn't going anywhere. But the file is proprietary, the seats are a subscription, and the canvas lives in someone else's cloud. Here's the honest read on when Figma is still the answer — and when owning an agent-native, local-first workflow wins.
Figma is excellent. We’ve shipped real work in it for years, and this isn’t a “Figma is dead” post — it very much isn’t. The fact that we built an open-source layer instead of another canvas isn’t a complaint about Figma’s craft. It’s a bet that the next decade of design work looks less like a cursor on an infinite canvas and more like an agent you already pay for, driving a workflow you actually own. This post is the honest read on Figma from a team building in the same category: what it does best, where it locks you in, what the open-source path actually looks like, and which one you should reach for this quarter.
What Figma actually is
Figma is the default collaborative design tool. A real-time multiplayer canvas in the browser, with Dev Mode for handoff, FigJam for whiteboarding, a deep plugin marketplace, and a growing set of AI features bolted onto the same surface. Pricing is per-seat per-month, tiered by role and by org.
It does a handful of things better than anything else:
- Real-time canvas collaboration. Five people in one file, cursors live, comments inline. Nothing in open source matches the multiplayer polish.
- Pixel-precise vector work. Auto Layout, constraints, variants, components — the canvas primitives are mature and the muscle memory runs deep.
- A huge plugin ecosystem. A decade of third-party plugins, community files, and templates you can drop in.
- Handoff that teams already know. Dev Mode, inspect, redlines, and a workflow engineering has been trained on for years.
If your work is a designer painting precise screens for other humans to review on a shared canvas, Figma is still the answer, and it’s a good one. The differences worth caring about live one layer down — in who owns the file, the workflow, and the cost curve.
Where it locks you in
Figma carries four pieces of lock-in worth naming upfront, because the pricing pages don’t.
The file is proprietary. Your design lives in Figma’s format, inside Figma’s servers. You can export PNGs and dev specs, but the source of truth — components, variants, the live design system — is only fully legible inside Figma. There is no plain-text version of your work that survives the tool.
The runtime is hosted. The canvas is the cloud. For agency work or pre-launch creative under NDA, “where does this file live” is a procurement conversation, not a setting. Local-only isn’t a mode.
The plugins aren’t portable. Figma’s plugin ecosystem is real and deep — but every plugin runs inside Figma’s runtime, against Figma’s API. A workflow you build there can’t be lifted out and run by an agent on your laptop, or composed into a pipeline that doesn’t start with the Figma canvas.
The bill is per-seat, forever. Subscription seats are fine for a stable design team. They get awkward for a fast-growing org, and they’re a non-starter for the long tail of contributors, contractors, and one-off collaborators who’d otherwise pick up the same workflow.
None of these are bugs. They’re the shape of a hosted, collaborative-canvas product, and Figma is the best version of that shape. We’re just not building for the canvas — we’re building for the agent.
The shift Open Design bets on
Open Design isn’t a Figma clone. There’s no infinite canvas and no multiplayer cursors. It’s a thin skill layer that turns the coding agent you already use into a design engine. The four primitives are skills, systems, adapters, and the daemon — and the important part is that they’re all just files:
- Every skill is a
SKILL.mdfile you can read, fork, and send back as a PR. - Every design system is a portable
DESIGN.mdfile — including the one we ship for Figma itself. You can open it in any editor, diff it in git, and it outlives whatever tool reads it next. - Every agent adapter is ~80 lines of TypeScript.
What that buys you is the opposite of the four lock-ins above:
- The file is plain text. Skills and systems are Markdown in a repo. Your design system is legible without the tool.
- The runtime is local. It runs on your laptop via
pnpm tools-dev, or you deploy it yourself. Prompts go to the model provider you chose — nothing routes through us. - The workflow is portable. A skill is a folder. It composes into any agent on your
$PATH, not a single vendor’s plugin runtime. - BYOK by default. Paste any OpenAI-compatible
base_urland key; your tokens go straight to the provider. Apache-2.0, no signup, no per-seat bill.
The mental model: Figma is a canvas you rent. Open Design is a workflow you own.
Side-by-side
| Figma | Open Design | |
|---|---|---|
| License | Proprietary | Apache-2.0 |
| Runtime | Hosted (browser, Figma cloud) | Local daemon (pnpm tools-dev) + optional self-host |
| Source format | Proprietary .fig | Plain-text SKILL.md / DESIGN.md in a repo |
| Primary surface | Real-time multiplayer canvas | Agent-driven generation + sandboxed preview |
| Models / AI | Figma’s own AI features | Any OpenAI-compatible endpoint + detected coding-agent CLIs |
| Plugins | Marketplace, runs inside Figma | Forkable skill folders, run by any agent |
| Design systems | Figma libraries (in-tool) | Portable DESIGN.md files (incl. a Figma one) |
| Pricing | Per-seat subscription | Free; you pay your model provider directly |
| Handoff | Dev Mode, inspect, redlines | Any agent on $PATH, plus HTML / PDF / PPTX / ZIP exports |
| Self-hostable | No | Yes (laptop or your own deploy) |
| Data path | Files → Figma cloud | Prompts → your chosen provider; nothing through us |
The honest summary: Figma has the most polished collaborative-canvas experience on the market, and for a team of designers reviewing precise screens together, that polish is the product. Open Design trades the canvas entirely for a library — skills, systems, and agents designed to compose with the tool already on your laptop. Different shape, different bet.
Who should pick what
| If you are… | Pick |
|---|---|
| A design team doing real-time, multi-designer canvas work with live review | Figma. Nothing in open source matches the multiplayer canvas. |
| A designer doing pixel-precise vector and component work all day | Figma. The canvas primitives are mature and your muscle memory is worth real money. |
| An org already standardised on Figma with Dev Mode in the engineering loop | Figma. You’ve paid the integration cost; spend it. |
| A design engineer who already drives Claude Code, Codex, or Cursor from the terminal | Open Design. Your agent is the design engine; the skill layer adds taste and structure without a new app. |
| Anyone who needs BYOK, model choice mid-project, or local-only for sensitive briefs | Open Design. The reality is rougher than the marketing, but it’s the only contract that actually holds. |
| A team that wants a design system that survives tool churn | Open Design. DESIGN.md files outlive the tool that reads them. |
| An open-source contributor who wants to ship a design workflow the project can adopt | Open Design. Drop a folder, restart the daemon, send the PR. |
The dimension that decides it for most teams isn’t quality — Figma’s craft is real. It’s whether your work is a canvas to paint on, or a workflow to automate. If it’s the latter, you’d rather own it than rent it.
What to do next
If you already have a repeatable Figma job — export these frames, sync those tokens, rebuild that deck template — the fastest way to feel the difference is to port one of them into a plugin. Start with one annoying, repeatable task, not “replace Figma.”
Or just run the three-command quickstart and point it at the model you already pay for. The whole thing lives in one repo and the first deck takes about ten minutes.
Related reading
- How to port a Figma workflow into an Open Design plugin — the concrete path for an export, token sync, or brand kit
- The open-source alternative to Claude Design — the same honest read, one tool over
- Why we built Open Design as a skill layer, not a product — the longer manifesto behind the “layer, not product” bet