Flowchart.fun

Open-source flowchart generation from plain text, honestly reviewed. No drag-and-drop required.

TL;DR

• What it is: An MIT-licensed web app that converts plain text with indentation and colon notation into flowcharts, mind maps, and process diagrams instantly [README][GitHub].
• Who it’s for: Developers, technical writers, and solo founders who think faster in text than with a mouse — anyone who finds Lucidchart or Miro exhausting for quick diagrams.
• Key strength: The fastest path from “I have an idea” to “I have a flowchart.” No node-dragging, no alignment fussing — just type and the diagram appears [README].
• Key weakness: Self-hosting the full feature set requires a Pro Vercel account (not a simple Docker deploy), and the premium tier dependencies — Vercel, Supabase, Stripe, Sendgrid — make a truly independent self-host complicated [README].
• GitHub standing: 3,351 stars. Modest but real. Listed as the only open-source option in GetApp’s flowchart software category across multiple regional listings [README][1][2].
• Pricing reality: There is a free web tier and a paid Pro tier on flowchart.fun’s SaaS. Specific pricing numbers were not available in reviewed sources — check the pricing page directly before making decisions.

---

What is Flowchart.fun

Flowchart.fun is a browser-based diagramming tool built on a core idea that’s genuinely different from every drag-and-drop competitor: you describe your diagram in text, and it renders immediately. The syntax is minimal — indentation for hierarchy, colons for edge labels, parentheses for back-references to existing nodes:

Node A
  goes to: Node B
  and: Node C
    goes back to: (Node A)

That input produces a live flowchart. No mouse required [README].

Under the hood it’s a React app using cytoscape.js for graph rendering, with a custom parser called Graph Selector handling the text-to-graph translation. The project is MIT-licensed and has been running long enough to accumulate 3,351 GitHub stars and a Discord community for contributors and translators [README][GitHub].

The project is developed by tone-row, a small independent studio. It’s not VC-backed, not YC-backed, not a multi-hundred-person team. It’s a focused tool that does one thing — text-to-diagram — and has attracted a community that finds that specific thing valuable enough to use and contribute to.

---

Why people choose it

The third-party review landscape for Flowchart.fun is sparse. The reviewed sources are GetApp directory listings [1][2][4][5] that don’t contain detailed user reviews for this specific tool, and the remaining source [3] covers a different product entirely. What follows is grounded in the README, the product itself, and the competitive context visible from those directories.

The honest reason people choose Flowchart.fun is typing speed beats dragging speed for technical users. If you’ve ever spent 20 minutes aligning boxes in Lucidchart for a five-node process diagram, the appeal is obvious. You type, it renders, you’re done.

The GetApp listings [1][2] reveal something worth noting: in a category of 35+ flowchart tools, Flowchart.fun is the only entry tagged “Open Source”. Every other option — Lucidchart, Miro, draw.io, Visio, SmartDraw, FigJam — is either proprietary SaaS, freemium-with-closed-source, or both [1][2][4][5]. That’s a real differentiator for teams with data sovereignty concerns or license-conscious procurement.

The text-based approach also creates an artifact that’s version-controllable. A Miro board is a blob. Flowchart.fun source is plain text — you can commit it, diff it, review it in a PR. For development teams documenting architecture or processes, this matters more than feature count.

What it’s not is a collaborative whiteboard or a complex diagramming suite. If you need swimlanes, database schemas, UML class diagrams with all notation, or real-time multi-cursor editing with sticky notes, Flowchart.fun isn’t trying to be that. Its scope is intentionally narrow.

---

Features

Based on the README, GitHub repository, and product description:

Core diagram engine:

• Text-to-flowchart rendering with live preview [README]
• Indentation-based hierarchy syntax with colon edge labels [README]
• Back-references to existing nodes using parentheses — enables cycle representation [README]
• Built on cytoscape.js for graph layout and rendering [README]
• Support for flowcharts, mind maps, and process diagrams per the official description [website meta]

Editor and workflow:

• Browser-based — no install required for basic use [README]
• Fast iteration: changes render immediately as you type [README]
• Multi-language UI via gettext .po files — community-contributed translations [README]

Premium / login features (require account setup):

• Saved diagrams and user accounts (Supabase backend) [README]
• Export options (inferred from Stripe gating of premium features)
• Additional features gated behind paid subscription via Stripe [README]

Development and self-hosting:

• MIT license — source is fully open [README]
• Two run modes: pnpm dev for the base app without login features, vercel dev for the full stack [README]
• Jest unit tests and Playwright e2e tests [README]
• Custom syntax parser (Graph Selector) maintained as a separate open-source package [README]

What’s notably absent: Real-time collaboration, embedded integrations with other tools, export to Confluence or Google Docs, import from other diagram formats, and anything resembling a template library. These aren’t oversights — they’re scope choices.

---

Pricing: SaaS vs self-hosted math

Flowchart.fun SaaS: The site offers a free tier and a paid Pro tier. Specific pricing numbers were not present in any reviewed source — verify current numbers at https://flowchart.fun directly. What is known: premium features are gated behind Stripe, implying a subscription model [README].

Competitors for context:

• Lucidchart: Free tier limited to 3 documents; Individual plan ~$9/mo; Team plan ~$9/user/mo [2][4][5]
• Miro: Free tier (3 boards); Starter ~$10/user/mo; Business ~$20/user/mo [1][2]
• draw.io (diagrams.net): Completely free as a SaaS; paid desktop app available; open source [2]
• Microsoft Visio: ~$5–$15/user/mo (Plan 1/2); desktop license ~$280–$580 one-time [4][5]
• SmartDraw: ~$9.95/user/mo (team plan) [1][2]

Self-hosted math — the honest version:

Unlike most tools reviewed here, Flowchart.fun self-hosting is not a Docker-compose-on-a-VPS situation. The README is explicit: running with login/premium features requires a Pro Vercel account because it uses more than 12 serverless functions [README]. Vercel Pro is $20/month per member minimum.

You can self-host the stripped version (pnpm dev — no login, no saves, no premium features) on any Node.js host for effectively zero marginal cost. But if you want the full product — user accounts, saved diagrams, collaboration — you’re looking at Vercel Pro + Supabase + Sendgrid costs, not a $6 Hetzner VPS [README].

The practical comparison: For a solo user who just needs fast diagrams without paying a SaaS subscription, Flowchart.fun’s free SaaS tier covers most use cases. The self-hosting story is more compelling as a budget argument for draw.io (which has always been free) than it is as an alternative to paying $9/mo for Lucidchart.

---

Deployment reality check

Self-hosting Flowchart.fun to full parity with their hosted version is genuinely complex compared to most tools in the self-hosted space. The stack required [README]:

• Vercel account — specifically Pro, due to serverless function count limits. This costs money.
• Supabase — for user auth and saved diagram storage.
• Stripe — for subscription management of paid features.
• Sendgrid — for email (account notifications, invites).

This is a Vercel-native application, not a containerized server. You can’t point a reverse proxy at a Docker image and call it done. The .env.example file in the repo surfaces all four external service dependencies immediately.

Realistic deployment paths:

1. Just run the free version locally or on any Node host: Clone, pnpm install, pnpm dev. No external dependencies. Loses login, saves, premium export. Takes 15 minutes. Good enough for a team that just wants the diagram editor without accounts.

2. Full self-hosted with all features: Requires provisioning Supabase project, Stripe account, Sendgrid API key, and a Vercel Pro account. Realistically 4–8 hours for someone comfortable with these services. Monthly ongoing cost: Vercel Pro ($20/mo minimum) + Supabase free tier + Sendgrid free tier. Total: $20+/mo.

3. Use their hosted SaaS: Fastest path. Check current pricing at https://flowchart.fun.

The self-host story is not the main value proposition here, unlike Activepieces or n8n where self-hosting is core to the pitch. Flowchart.fun’s MIT license matters most for forks and embedding, not for escaping SaaS costs.

---

Pros and Cons

Pros

• Fastest diagram creation for keyboard-oriented users. No drag-and-drop overhead. Text in, diagram out. For simple process flows, it genuinely beats every GUI-first tool on time-to-diagram [README].
• MIT license. The only open-source option in GetApp’s flowchart category across multiple regional listings [1][2][4][5]. Fork it, embed it in your product, deploy it for clients.
• Version-controllable source. Because diagrams are plain text, you can store them in git, review them in PRs, and diff them like code. No other tool on the GetApp list offers this naturally.
• Zero-friction free tier. The web app works without an account for basic use. No credit card, no trial limit countdown.
• Active small community. Discord, community-contributed translations, and a separately maintained parser library suggest the project is a real ongoing thing, not abandonware [README].
• Deployable without premium services. The base diagram editor runs on any Node.js host with no external dependencies [README].

Cons

• Self-hosting full features is Vercel-dependent. Not the independent infrastructure control story you get from truly self-contained Docker apps. Requires Vercel Pro ($20+/mo) for the full stack [README].
• Narrow feature scope by design. No real-time collaboration, no template library, no integration with Confluence/Notion/Google Docs, no swimlanes. If you need those, this tool doesn’t have them.
• Limited third-party reviews. The tool doesn’t appear in in-depth review roundups the way Lucidchart, Miro, or draw.io do. Community signal is GitHub stars and Discord activity — smaller evidence base.
• Modest traction. 3,351 stars is real but puts it far behind draw.io (~47K+ stars), Miro (not open source), or Excalidraw (~80K+ stars) in mindshare [GitHub].
• Syntax learning curve. The indentation-based notation is intuitive after 10 minutes, but it’s not zero — users expecting drag-and-drop will bounce immediately.
• Pricing opacity. Specific Pro plan pricing wasn’t findable in the sources reviewed. A tool targeting paying users should have publicly accessible pricing.

---

Who should use this / who shouldn’t

Use Flowchart.fun if:

• You’re a developer or technical writer who reaches for the keyboard first and finds GUI diagramming tools painful.
• You want to store diagrams as plain text in a git repository alongside code.
• You need a fast, zero-friction tool for one-off process diagrams without signing up for yet another SaaS subscription.
• You’re building a product and want to embed or fork an MIT-licensed diagram generator.
• You want the only open-source entry in the flowchart software category [1][2].

Skip it (use draw.io instead) if:

• You need a completely free diagramming tool with a wide feature set, real-time Google Drive integration, offline desktop app, and zero subscription cost. draw.io covers all of that and is also open source [2][4].

Skip it (use Miro or FigJam instead) if:

• Your team needs a collaborative visual workspace with real-time editing, sticky notes, whiteboard features, and multiple diagram types in one canvas [1][2][4][5].

Skip it (use Lucidchart instead) if:

• You need enterprise-grade diagramming with Confluence/Jira integration, data-linked diagrams, org chart tools, and proper SSO — and you’re willing to pay per-user pricing for it [2][4][5].

Skip it (use Excalidraw instead) if:

• You want open-source, self-hostable, collaborative, hand-drawn-style diagrams with a clean UI and no syntax learning curve.

Skip it (stay on Visio) if:

• You’re in a Microsoft-stack org and need floor plans, network diagrams, complex UML, and Office/Teams integration [4][5].

---

Alternatives worth considering

Flowchart.fun sits in a specific niche — text-first, MIT, minimal. The alternatives depend on what you’re actually trading off:

• draw.io (diagrams.net) — Free, open source (Apache 2.0), GUI-based, desktop app available, Google Drive integration. The default recommendation for anyone who wants free diagramming without constraints [2][4][5]. Lacks the text-first workflow.
• Excalidraw — MIT license, hand-drawn aesthetic, self-hostable with Docker, real-time collaboration. Better for whiteboard-style visual thinking than structured flowcharts.
• Mermaid.js — Open source, text-to-diagram like Flowchart.fun but for developers embedding diagrams in documentation (GitHub README, Notion, Obsidian, GitLab). Not a standalone app but embeds everywhere.
• Lucidchart — The enterprise standard. Expensive at scale, closed source, but the most polished GUI and integration catalog [2][4][5].
• Miro — Collaborative whiteboard platform. Overkill for flowcharts alone but good if teams already use it for other visual work [1][2][4][5].
• Whimsical — Clean, fast GUI for flowcharts and wireframes. Closed source SaaS, free tier limited [1].
• PlantUML — Text-to-diagram for developers who need UML specifically. Mature, embeds in CI, but the syntax is more verbose and the output less polished.

For the text-first diagramming niche specifically, Flowchart.fun and Mermaid.js are the main open-source options. They solve slightly different problems: Flowchart.fun is a standalone editor for quick visual diagrams; Mermaid is for embedding diagrams in documents and wikis.

---

Bottom line

Flowchart.fun is a sharp tool for a narrow job. If you think in text, want a flowchart in 90 seconds, and would rather commit a .txt file than export a .png, it’s the fastest option in the category and the only MIT-licensed one in its tier [1][2]. The catches are real: self-hosting the full version isn’t simple (Vercel-native architecture, four external service dependencies), and the tool doesn’t try to compete with Miro or Lucidchart on features. For a non-technical founder escaping Lucidchart bills, draw.io is probably the honest answer — free, open source, and covers the full feature set. Flowchart.fun earns its place for the specific user who finds GUI diagramming a productivity tax and wants to fix that permanently.

---

Sources

1. GetApp — Best Flowchart Software for Mac 2026 (directory listing, category context, “Open Source (1)” filter). https://www.getapp.com/project-management-planning-software/flowchart/os/mac/
2. GetApp — Best Flowchart Software 2026 (35+ tools directory, competitive landscape, open source classification). https://www.getapp.com/project-management-planning-software/flowchart/
3. GetApp NZ — Flowchart Software Prices & Reviews 2026 (regional listing, competitor pricing context). https://www.getapp.co.nz/directory/1263/flowchart/software
4. GetApp UK — Flowchart Software Prices & Reviews 2026 (regional listing, competitor set). https://www.getapp.co.uk/directory/1263/flowchart/software

Primary sources:

• GitHub repository and README: https://github.com/tone-row/flowchart-fun (3,351 stars, MIT license)
• Official website: https://flowchart.fun
• Graph Selector parser: https://github.com/tone-row/graph-selector