Software your whole team can see — and your AI can safely change

Graphden keeps your program as a living, typed graph in a database — not text in files. Engineers review structure instead of prose diffs, teammates compose ready-made typed blocks without touching code, and AI edits land as inspectable, effect-gated changes. And it's already running: no build step, no deploy step.

Try the demo — guided, no sign-up Open the editor Source (AGPL)

The demo drops you into a live, sandboxed workspace that self-destructs after an hour — an interactive lesson walks you through your first function. This page is itself a graphden graph, served by the platform it describes.

The Graphden editor: selecting web-server, stepping into its error-boundary handler, then the inspector's Bindings and Versions tabs — typed slots, tracked effects, version history

What a function looks like

{:name :my-about-page
 :parent :html-page-route
 :args {:path "/about"
        :title "About"
        :body :my-about-body       ; returns hiccup
        :head :graphden-page-head  ; default CSS
        :scripts {:value []}}}    ; no JS

That's a page, live at /about.

A row, not a file. :parent picks the template; :args bind its slots. The unbound ones stay free — the Run form asks for them.
Type-checked as you bind. :body must return hiccup, :path must be a path; a wrong wire is refused in the editor, not at 3 a.m.
Already deployed. Save it and the route answers. Branch it, diff it (above), merge it — the same way you'd review anything else.

Paste it into the editor, or follow lesson 10 where it comes from.

One change — two ways to review it

In text: nine lines touched, the change buried in rewrapping

- export const notify = (channel, msg) =>-   post(channel, render(msg))+ export const notify = (+   channel = ONCALL_CHANNEL,+   msg,+   urgent = true+ ) =>+   post(channel,+     urgent ? renderUrgent(msg) : render(msg))

In Graphden: the structure that actually changed

The editor's Review dialog: 'What changed — 4 differences across 2 functions'. Under :notify, arg body rebinds from :render-message to :urgent-message and arg url changes from the team webhook to the on-call one; :urgent-message is a new function with its value.

The same edit in compare mode on the canvas: the branch chip reads 'Δ vs feature/urgency', every changed function in the Explorer carries a one-line digest and the untouched dependant is marked ∿ changed-inside; on the canvas the notify card and its url value are ringed, the url the branch holds sits under the current one struck through, and the branch's replacement for :render-message — :urgent-message — hangs above it as a dashed ghost subtree.

Same edit, as the editor renders it: each rebinding as old → new, the new function by name, its seeded value — whether a human made it or an AI did. Flip on compare mode and the diff becomes the graph: the value the branch holds sits under yours, the function it swapped in hangs beside the card as a ghost of its own subtree, and everything that merely depends on the change is marked changed-inside. Click either shot for full size.

One graph, three ways to work on it

Engineers review structure, not prose

Every function is a row; composition is edges. The whole program is queryable, versionable and branchable — like git, except it stays alive while you edit it. A change lands as a structural diff — added N functions, changed M bindings — so review reads the behaviour, not reformatted text.

Teammates compose without code

Ready-made typed blocks wire together by shape, and every connection is type-checked as you make it — so a support engineer or a manager can extend a workflow without being able to break it. Secrets are taint-tracked through composition and redacted at the edges.

AI edits it can't silently break

An AI proposal is a graph change: typed, effect-declared (db, network, process — gated at runtime), structurally valid by construction. You inspect exactly what it did in the same editor you build in — behaviour, not 400 lines of reformatted text.

How it works

Compose functions in the editorStart from small typed primitives (http, storage, collections, logic) and compose them into your own functions by binding arguments — every binding is type-checked as you type.

Run it — it's already deployedHit ▶ to execute anything with arguments, or attach your function to an HTTP route (your API, a page, an inbound webhook) or a schedule. There is no build artifact: the graph in the database is the deployment, and what you see in the graph is what runs.

Branch, diff, merge — the whole systemBranches give you dev/prod views of the same graph with per-branch execution. Diff and merge changes like code, with conflicts surfaced in the editor — whoever made them, human or AI.

New here? The tutorial walks the whole path in 36 short lessons — first function to types, branches, tests and a running service.

Pricingcloud

Capability	Demo	Free	Cloud Shared	Cloud Dedicated
Price	none — no sign-up	0	€15 / organisation / month	€90 / month
Outbound HTTP / your own DB / bots	—	✓ metered	✓	✓
Functions	200	500	5,000	5,000
List items	2,000	50,000	500,000	500,000
Outbound calls / min	0	120	6,000	uncapped
Always-on services	—	—	—	✓ dedicated pod
Bring your own executor	—	—	✓	✓
Workspace	1-hour sandbox	persistent while used*	persistent	persistent

* A free organisation nobody signs into, runs or edits for 60 days is scheduled for deletion, with an email 14 days ahead and a reminder 2 days before; any sign-in cancels it. Paid organisations are never scheduled.

Paid plans are in founding-user beta: the first 30 organisations get Cloud Shared or Cloud Dedicated free until billing launches, then six months at half price — in exchange for feedback. Ask for a plan with your organisation name. Self-hosting is free and uncapped, always. Organisations that cannot accept the AGPL can take a commercial licence for the core.

Start free — no card, no install Try the demo first

Self-host it

One binary, AGPL

The cloud runs the exact same open-source core you can run yourself — multi-tenancy is an optional addon, not a fork. Postgres is the only dependency.

Quick start

git clone https://github.com/Graphden/graphden
cd graphden
bb rebuild        # jar + docker + start
open http://localhost:9002

Work with the author

Graphden is built by one engineer who also builds on it. If you would rather have the result than the tool, the same person does the work — on your cloud organisation or your own server.

Pilot: from €1,500

An integration, an automation or an internal service built in your graph in two to four weeks, fixed price agreed up front. You keep everything; it runs on the open core.

Self-host support: €300 / month

Next-business-day answers, help with upgrades and migrations, incident diagnosis, a monthly check-in. Up to four hours a month, more at the hourly rate.

Hourly: €60–80

Anything smaller, and the published rate for contributor work funded through the project's Open Collective.

Write to hello@graphden.dev with two sentences about what you need. Details: SUPPORT.md.

Support the project

Graphden is built in the open by one engineer, with AI as an accelerator and every change reviewed by a human. If it's useful to you, star it, break it, tell us — or fuel the servers:

♥ Support on Boosty ★ Star on GitHub Join Discord Telegram

…or send crypto directly (self-custodied):

BTCbc1qqp3etkkceygs9n8vvhuwm6fc4u56ceflr6e6nu

ETH / ERC-200x5D3c2E2272F0b7244184Cb3231b6f21D8a1c97fD

TRON / TRC-20TShPHXzRBuneddGfSK9DXtPV6BEAghrbbE