Forge
Sign in Get Forge
Claude Code builds it · your machine runs it

Describe it.
Run it.

Forge turns a sentence into a real desktop app — sandboxed, installable, with accounts, sync and voice it never had to write. Your own Claude Code does the building, so Forge holds no model key and there is no per-token bill.

New app free · no card · no API key
+ Sandboxed + Accounts + Voice
Build it →
How it works
01

Say what you want

Forge plans before it types: a spec pass writes the screens, the data and the flow, and asks you the two or three questions it genuinely cannot guess.

02

Watch it build

The console shows the plan as it lands. Every step is a local commit, so “put that back” is a rollback, not a re-prompt.

03

Run it, then share it

An app that does not compile never reaches your grid. The ones that do run on their own origin, with only the permissions you approved — and publish with one click.

Built by the model, driven by a script, screenshotted
Keelhaul · 12.8 min · two accounts, two machines
Keelhaul — a voice-and-text bar In call
Keelhaul: a chat app built by Forge, showing a voice call in progress between two accounts

One prompt, twelve minutes. Then published to the store, installed by a second account on a second machine, and a message sent each way — with the voice call still connected after its window was closed.

18
Apps built by the real model
12.8min
Prompt to installed app
8/8
Formula-engine probes passed
$0
Forge spends on inference
What it has actually built
The store →
Green Bar
Spreadsheet · 12.8 min

A real formula engine. =SUM, dependent recalculation, cycles named instead of crashing, and it survives a restart.

FLATBED
Video editor · 24.7 min

Non-linear timeline: trim, speed, grading, multi-track, ripple delete, titles, export. Eleven of the twelve features asked for.

Keelhaul
Chat + voice · 12.8 min

Servers, channels, invites and a voice call that survives closing the window. Published, then installed by someone else.

Coms
Discord replica · 20 min

A 5.3 KB spec, one shot: four-column shell, roles, hover actions, context menus and a ⌘K switcher.

Why it is not another chat window

It touches the machine

Files, windows, the tray, the microphone. An app can hold the background so a call keeps running after you close its window.

Generated code is untrusted

Own origin, own storage, no Node, no network unless you granted it. The permission list is on the app's page before you install.

A backend it did not write

Accounts, spaces, messages, documents, files and calls arrive as one API — and the platform pays for them while the app is small.

Your first app is one sentence away.

No card, no API key, no install beyond Forge itself.

Get Forge
Pricing

Free until it is real.

Forge does not sell you inference — your own Claude Code subscription already pays for that. What costs money is the backend your apps use once other people are using them, and the platform carries that until an app is genuinely popular.

Free
$0
For everything you have not shipped yet
Get Forge
  • Unlimited apps on your own machine
  • Publish to the store
  • Accounts, sync, files and voice
  • Platform pays the backend under 100,000 installs
  • Community support
Premium For authors with a hit
$9/mo
For the one people actually use
Go premium
  • Everything in Free
  • Thresholds can be switched off per app
  • Priority in the build queue
  • Full analytics history
  • Email support
Self-hosted
$0
For when the data cannot leave
Read the deploy guide
  • One docker compose up
  • Postgres, Redis, S3-compatible storage
  • Your domain, your certificates, your backups
  • Same code as the hosted service
  • No licence fee, no seat count
Model spend
$0 through Forge
Your Claude Code subscription does the building.
Threshold
100,000 installs
Past it, the app keeps working and the bill moves to you.
Notice
Before it flips
Nothing switches off, and nothing is charged by surprise.
Questions
Do I need an Anthropic API key?

No. Forge drives the Claude Code CLI you already have. There is no API client anywhere in it, and no key to leak.

What happens at 100,000 installs?

The app carries on exactly as it did. Its backend bill moves from the platform to you, and you are told before that happens.

Where does my code live?

On your machine, in a git repository per app. Publishing uploads a built bundle; it does not take your workspace.

Can an app read my files?

Only if you granted it that, at install, from a list you saw. Apps get their own origin, their own storage and no Node.

Do you train on my apps?

Forge has no model of its own and no training pipeline. Whatever applies to your Claude Code subscription is what applies.

Can I leave?

Export an app as a standalone Electron project and it runs without Forge. Self-hosting the cloud is one compose file.

Start free. Decide later.

No card, no trial clock, no downgrade penalty.

Get Forge
Start / Quickstart

Quickstart

You need Forge and a working Claude Code CLI. Forge drives the CLI you already have, so there is nothing to configure and no key to paste.

Building costs whatever your Claude Code subscription costs — Forge adds nothing. The cloud is free until an app crosses its threshold.

1. Describe the app

Write what it does and who uses it. Name the people, not just the features: “members can start a voice channel, moderators can kick” beats “voice support”.

a bar for my crew: servers, channels, invites, and a voice
channel anyone can join. moderators can kick.

drafting spec ............ 6 screens, 4 collections
building ................. ok 12.8 min
verifying ................ compiles, first paint clean

2. Steer it

The build console shows the plan as it lands and asks when it hits a real decision. Every step is a local commit, so a correction is a rollback plus one more sentence — never a fresh start.

3. Publish it

The tile menu has Publish to cloud. That uploads a built bundle and its manifest; your workspace stays on your machine. Anyone with the link can then install it into their own Forge.

Give the app a backend

Ask for it in the prompt and the agent wires it up. This is the whole surface:

const { space } = await forge.cloud.spaces.create('The Bar');
const chat = forge.cloud.channel(space.id, 'general');

await chat.send({ text: 'ahoy' });
chat.subscribe((m) => render(m));           // live
await chat.history({ after: cursor });      // resume

const call = forge.cloud.call(space.id);   // voice, peer to peer
call.join(localStream, (user, stream) => attach(user, stream));

Keep running when the window closes

A call should not drop because someone closed the window. Hold the background and the shell parks the app alive; pin a tray chip so it is obvious what is still running.

forge.background.hold();                     // close hides, not quits
forge.tray.set('●', 'In call · The Bar');
// later
forge.tray.clear(); forge.background.release();

Measure it

Report what your app does and read it back on its Analytics page. Events are batched, session ids are yours and never joined to an account, and raw rows expire after thirty days — the daily rollup is what the charts read.

forge.cloud.track('call.joined', { channel: 'general' });
forge.cloud.track('invite.used');

Self-hosting

The service is one compose file: Caddy for TLS, Postgres for the store, Redis for fan-out between instances, MinIO for blobs, and an hourly database dump. Set five environment variables and bring it up.

$ cp .env.example .env   # secret, owner email, passwords
$ docker compose up -d --build
forge-cloud listening on :4600 · store postgres · fan-out redis

Without DATABASE_URL the service runs on SQLite instead — correct, tested the same way, and limited to one instance. The full guide is docs/cloud/DEPLOY.md in the repository.