Sixteen months ago I compared Penpot and Figma as two flavors of the same job: drawing rectangles, sharing components, handing CSS to developers. That comparison is now a period piece. Since then, Figma bolted a prompt-to-app generator onto its platform and started metering it by the credit, while Penpot kept shipping open-source releases and quietly declined to build a generator at all.
So the question isn't "which tool draws better rectangles" anymore. It's "do you want AI built in and billed, or bolted on and free?"
A quick honesty note before the comparison. The topic feed that queued this article flagged "Penpot 2.17" as the current release, and while I was pulling sources that stopped being true: Penpot 2.18 landed on September 9, 2026, mid-research. Version numbers in tool comparisons rot fast. Everything below reflects mid-September 2026, and I've dated the claims so you can tell when they've expired.
TL;DR: Figma Make is a credit-metered, prompt-to-app generator that turns a sentence (or your existing Figma frames) into a working web prototype with real code and an optional Supabase backend. Penpot 2.18, released September 9, 2026, ships no generator at all: it offers an MCP server so any AI agent you already run can drive your files, and it spends its release notes on rendering, stroke-to-path, and a new quote-priced Enterprise tier while the core stays free and open source. Make wins on speed to a clickable thing. Penpot wins on cost, code honesty, and not renting your iteration loop. If you want the pre-AI baseline first, read the original Penpot vs Figma comparison.
What is Figma Make in September 2026?
Figma Make is Figma's prompt-to-app tool: you describe an interface, or attach existing frames and components, and it generates a working web app with real code, not a picture of one. It debuted at Config in May 2025, went generally available that July, and picked up Make kits and design attachments through spring 2026. Output is prototype-grade React with utility styling, editable in a built-in code editor, and publishable to a live URL (Figma).
Two additions moved it past toy status. First, library context: on paid plans Make reads your team's component library, so generations come out looking like your product instead of a generic template. Second, backends. Make's Supabase integration means a prompt that implies data ("a signup form", "a saved list") can get auth, a Postgres database, and file storage wired in without you leaving the file (Supabase).
Published Make apps get their own URL, aren't indexed by search engines by default, and custom domains are tiered: 10 on Professional, unlimited on Organization and Enterprise. That's a real product, not a demo.
And the whole thing sits inside the wider AI push Figma made this year, alongside the Agent, code layers, and native motion tools it announced in June. We covered that shift in the Figma Config 2026 recap, and Make is the piece of it most working designers actually touch weekly.
What did Penpot 2.18 actually ship?
No generator. Let's get that out of the way, because it's the headline absence in an AI-obsessed year, and Penpot seems entirely unbothered by it.
What 2.18 (September 9, 2026) did ship: stroke-to-path conversion for everyone on the new WebGL renderer, shape and free-draw flyouts in the toolbar, community-contributed line and arrow tools, and font names in the selector rendered in their own typeface so you can preview before applying (Penpot). Small things. Craft things. The kind of features a tool ships when it's sanding the daily workflow instead of chasing a demo reel.
The bigger strategic move is Penpot Enterprise: a new paid tier with advanced permissions, a choice of identity providers, and an admin panel, priced by quote. The design features stay in the free build; what's being sold is governance. I'd call that the healthiest possible sign for the free tier, because it means the business model taxes compliance departments, not designers.
The AI story lives one release back. Since roughly 2.16 in June 2026, the MCP server stopped being a beta signup and became a normal integration: generate a key, point an MCP-capable agent at it, and the agent can read and manipulate your actual Penpot files. If you already use a coding assistant this way (we walked through the pattern in Claude for designers), Penpot slots into that loop instead of replacing it.
Rendering keeps improving underneath: the WebGL work from 2.16 and the WASM prototype viewer from 2.17 are precisely aimed at the "lags on big files" complaint that has trailed Penpot for years. Is it fully solved? I haven't stress-tested a 500-component library against 2.18, so I won't claim it is. The direction is unmistakable, though.
Two philosophies, one table
Here's the September 2026 state of play, side by side:
| Dimension | Figma Make | Penpot 2.18 |
|---|---|---|
| AI generation | Built in, prompt-to-app with library context | None built in; MCP server for external agents |
| AI cost | Metered credits (~30 simple, 75-100+ complex per prompt) | Whatever your own agent costs; Penpot adds nothing |
| Output | Working React prototype, live URL, optional Supabase backend | Design files in web-native CSS; free Inspect for devs |
| Entry price | Free tier; $16/mo full seat (annual) for real use | $0, cloud up to 8 members; self-host unlimited |
| Source code | Proprietary | Open source, self-hostable |
| Ecosystem | Large plugin and template market | Small but growing |
| Governance tier | Organization $55, Enterprise $90 per user/mo | New Enterprise tier, quote-priced |
The pattern isn't "one tool is ahead". It's two different bets about where value lives. Figma bets the model's output is the product, so it owns the model relationship and meters it. Penpot bets the file format and the protocol are the product, so it opens both and lets the model market fight elsewhere.
Figma sells AI by the credit. Penpot ships the socket and lets you bring your own model.
What does the credit meter cost in practice?
This is where I spent most of the fact-checking time, because the numbers moved twice this year. Figma started enforcing AI credits on March 18, 2026, then rebalanced allowances on August 25, roughly doubling Professional and adding about 60 percent to Organization and Enterprise.
The current table, straight from Figma's help center as of mid-September: Starter accounts get 500 credits a month with a 150-per-day cap. A Professional full seat gets 3,000 a month. Organization gets 3,500, Enterprise 4,250, and Dev, Collab, and View seats are flat at 500 regardless of plan (Figma). Run dry and AI actions stop until the monthly reset, unless an admin buys more; pay-as-you-go has been reported at about $0.03 per credit.
Now do the arithmetic that matters. Figma's own estimate puts a complex Make request at 75 to 100 credits or more, and independent testing has clocked heavy agentic prompts well past that. A real Make session isn't one prompt; it's a first generation plus eight or ten refinement prompts. Call it 400 to 700 credits for an afternoon of honest iteration. A Professional seat covers maybe five or six of those afternoons a month. A free account covers one, if you pace yourself against the daily cap.
Is that expensive? Compared to an engineer's week, no, it's a rounding error. Compared to Penpot's number, which is zero forever, it reads differently. And here's my opinionated take, the one you're welcome to argue with: metering by the credit taxes exactly the behavior that makes design work good, which is trying the eleventh variant after ten fine ones. A designer who starts rationing prompts mid-exploration is a designer whose tool just edited their process. I think that cost is bigger than it looks on the invoice.
The counterweight is capability. Penpot charging nothing for AI is easy when it doesn't run any models for you. You'll pay Anthropic or someone else for the agent driving Penpot's MCP socket, so "free" really means "unbundled". For some teams unbundled is the whole point. For others it's three vendor relationships where Figma is one.
Where each one falls short
Figma Make's weak spot is what happens after the demo. Reviewers across 2026 keep landing on the same verdict: the output is superb for validating an idea and rough for shipping one. Generated code trends toward div soup, accessibility is hit-and-miss, and the visual output has a recognizable AI-default flavor unless you feed it strong library context. Treat it like a very fast junior who never pushes back, and you'll be happy. Treat it as a production pipeline and your engineers will not be. For the handoff-quality end of the market, the tools in our prototyping and developer handoff roundup are still the safer bet.
There's also lock-in gravity. Make files, Make hosting, Make backends, all of it deepens your Figma dependency at the exact moment Figma is repricing AI twice a year. That's not sinister; it's what platforms do. But it belongs in the decision.
Penpot's weak spots haven't changed shape since May, they've just shrunk. The plugin ecosystem remains a fraction of Figma's. Very large shared libraries still deserve a performance pilot on your own hardware before you commit, WebGL progress or not. And the bring-your-own-agent AI model, honest as it is, has a setup cost that a solo designer without a technical bent may never pay. Penpot asks more of you upfront and charges less forever; that trade has a personality type.
What genuinely surprised me during research: nothing in Penpot's 2.18 notes even gestures at a built-in generator. In 2026 that takes nerve. Whether it's principle or resourcing, the effect is the same: Penpot is betting that generation becomes a commodity you plug in, and that owning your files outlasts owning a model.
So which one should you pick?
Pick Figma Make if prototyping velocity converts directly into money for you: agencies pitching interactive concepts, PMs validating flows with users this week, teams whose component library is already deep in Figma and who'll benefit from generations that inherit it. Budget the credits like a real line item, keep an engineer in the review loop, and don't ship the generated code without adult supervision.
Pick Penpot if you're cost-sensitive, developer-heavy, self-hosting inclined, or building on design tokens where Penpot's native token model is still ahead of Figma's plugin-shaped answer. You give up the one-prompt magic trick and gain a tool nobody can meter, reprice, or acquire out from under you.
And if you're choosing for a whole team rather than yourself, the wider field comparison in our best UI design tools of 2026 puts both of these against the rest of the market.
My call, sixteen months after the first one? The gap between these tools got wider, not narrower, and that's healthy. Figma Make is the best argument yet that AI belongs inside the design tool. Penpot 2.18 is the best argument yet that it doesn't have to live there to be useful. I'd prototype in Make and keep my system of record somewhere that can't send me a bigger bill for thinking out loud.
