Brilliant vs Penpot

Penpot is the strongest open alternative to the big proprietary tools, and this page is going to say so more than once. It's a genuine professional editor: a real pen tool with bezier nodes, all five boolean operations, layout built literally on CSS Flexbox and CSS Grid, components with variants, native design tokens that follow a W3C standard, and shipping prototyping. It's MPL-2.0 licensed, you can self-host the whole thing, and its file format is open by design. If you want an open platform you can run on your own infrastructure and never be locked out of, Penpot is the answer, and nothing below is an attempt to talk you out of that.

Brilliant is not open source, and it won't pretend to beat Penpot on the axis Penpot was built to win. What Brilliant offers is a different shape: a native desktop tool whose agent access doesn't need a browser tab, whose files are plain text that diffs in Git without unzipping, and whose export and Figma interop run wider. This is a comparison between two good tools with different centers of gravity, so we'll concede generously and then be precise about the few places they actually differ.

Penpot facts on this page are current as of August 2026, checked against Penpot 2.17.1.

Where Penpot is genuinely ahead

Some of these are things Brilliant doesn't do at all, and pretending otherwise would be the fastest way to lose your trust.

• It's open source, and you can host it yourself. MPL-2.0, tens of thousands of GitHub stars, and a documented, supported deployment matrix: Docker, Docker Compose, Kubernetes with an official Helm chart, and more. Penpot calls itself "deployment agnostic," and it earns the phrase. Brilliant is not open source and offers no self-hosted edition.

• Its design tokens follow the W3C standard. Penpot's tokens adhere to the W3C DTCG format, with math and aliases, functions, token sets that cascade, and multidimensional themes, all importable and exportable as JSON. Brilliant's tokens are a first-party DSL, not a standards-compliant one. This is a real advantage and we're not going to soften it.

• It ships prototyping. Click, mouse-enter, mouse-leave, and delay triggers; navigate, overlay, and URL actions; dissolve, slide, and push animations. Brilliant is a static canvas today, with no interactive prototyping at all.

• Its layout is literal CSS. Flex Layout is built over Flexbox and Grid Layout over CSS Grid, with fractional, auto, and pixel track sizing and named grid areas. Designing in it "generates ready for production code."

• Its file format is open and inspectable. More on that below, because it's where the two tools are closest and the distinction is narrow.

Agent access without a browser tab

Penpot ships an official, free, first-party MCP server, and that deserves to be stated without hedging: it's a real agent story, it lives in the main repo, and it isn't paywalled. Any page that waved it away would be misleading you.

Here's the honest distinction, and it's about architecture, not capability. Penpot's MCP server doesn't talk to a backend directly. It drives a plugin running inside an open Penpot browser tab, and it writes to "the currently focused Penpot page." Penpot documents the consequences itself: the plugin UI has to stay open, a browser suspending an inactive tab can interrupt operations, and recent Chromium private-network rules require an explicit permission prompt. The tool surface is execute_code plus four helpers. It can absolutely write to your canvas; it just needs that live, focused tab to do it.

Brilliant's MCP server runs inside the desktop app itself, for as long as the app is open. There's no browser tab to keep focused and nothing to suspend. The agent drives the same canvas commands you do, over a hundred of them, each with full undo, and it can create, inspect, edit, search across every canvas in the workspace, and export to ten formats. Both tools keep the AI bill in your hands, too: Penpot ships no model and tells you to "manage the cost of your agents," and Brilliant is bring-your-own-key with no hosted inference. On that philosophy the two agree. Where they differ is the tab. What an agent can do in Brilliant →

Your designs, your disk, your git

This is the closest call on the page, so it gets the most careful wording.

Penpot's .penpot file is open and documented on purpose. It's a ZIP archive of JSON metadata plus binary media, and Penpot makes a point of it: "your design data is never locked in a proprietary format. You can always unzip a .penpot file and read the JSON to understand what's inside." That's true, and it's more than most tools offer. The caution here is real: Brilliant is not the only tool with an open format, and anyone who tells you otherwise is overselling.

The difference is narrower than open versus closed. A .penpot file is a binary ZIP, so it's not line-diffable as it sits on disk, and Penpot documents no Git integration. Brilliant's .bl files are plain, deterministic Blueprint text: one element per line, stable ordering, inline coordinates, hex colors. You can git diff two versions and read the change, branch a design the way you branch a feature, and git blame a stray color, all without unzipping anything:

 c16fc75741feed85 fr p(80,80) s(480,320) rd(16) "Hero"
-  88625e475868c087 r p(24,24) s(160,100) f[(r1,#F8F8F8)] rd(8) "Panel"
+  88625e475868c087 r p(24,24) s(160,100) f[(r1,#0080FF)] rd(8) "Panel"

And a published Brilliant project is itself a real Git repository with a clone URL. Both formats are genuinely open. Only one of them diffs in Git without a step in between.

Code out, and Figma both ways

Two smaller but real differences round out the picture.

On code export, Penpot states its own gap: its inspect and export are "currently CSS only but more are coming," with SVG and HTML markup alongside, and no React. Brilliant exports HTML in three flavors, React JSX, SVG, and PDF, and Copy As covers CSS, HTML, React, SVG, and Blueprint.

On Figma, Penpot imports through a Figma plugin that packages a file into a ZIP, and Penpot is candid that the path is one-shot rather than incremental, needs manual steps, and "may not be 100% reliable" on features that differ between the tools; prototyping doesn't survive the trip, and there's no documented path back out to Figma. Brilliant imports from Figma by URL, by page, or by node-id subtree, with a published carry-over list and a published list of what doesn't come across, and it also has Send to Figma, so a canvas can round-trip while a team is still deciding.

What Brilliant has that Penpot doesn't

• Agent access with no browser tab to keep focused. A desktop-resident MCP server driving over a hundred undoable canvas commands, versus a plugin that writes to whichever Penpot tab is currently focused.

• Plain-text files that diff in Git without unzipping. .bl is line-oriented text; .penpot is an open but binary ZIP with no documented Git integration.

• Wider code and markup export. HTML in three flavors plus React JSX, where Penpot is "currently CSS only."

• Figma interop in both directions. Import by URL, page, or subtree, plus Send to Figma. Penpot imports one-shot through a plugin and documents no export back.

• Native GPU shaders as first-class fills. Metaballs, metal, iridescent, and steel, composed with effects and exported to raster or video.

• A native desktop app on macOS, Windows, and Linux with files on local disk. Penpot is web-first, with no official desktop app and no documented offline mode.

What Penpot has that Brilliant doesn't

• Open source and self-hosting. MPL-2.0, the whole platform, with a supported Docker and Kubernetes deployment matrix. Brilliant has no self-hosted edition.

• W3C DTCG design tokens. A standards-compliant token system with math, aliases, sets, and themes, importable and exportable as JSON. Brilliant's tokens are a first-party DSL.

• Interactive prototyping. Real triggers, actions, and animations. Brilliant is a static canvas today.

• CSS-native layout primitives. Flex Layout over Flexbox and Grid Layout over CSS Grid, with named areas.

If open source, self-hosting, W3C-standard tokens, or clickable prototypes is the thing you need most, Penpot is a genuinely excellent choice, and you should take it.

At a glance

A new dance

Penpot and Brilliant want different things, and both are worth wanting. Penpot is building the open, self-hostable design platform, and it's winning that fight. Brilliant is building the design tool an agent can drive from your editor without a browser tab, with files that live in Git the way your code does. Concede Penpot everything it has earned, and the choice comes down to a short, honest list: do you want the open platform you can host yourself, or the plain-text canvas your agents and your Git history can both reach directly?

Read the full manifesto to see the rest of the argument, or install Brilliant and try it for yourself.