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.
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.
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.
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.
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.
A real formula engine. =SUM, dependent recalculation, cycles named instead of crashing, and it survives a restart.
Non-linear timeline: trim, speed, grading, multi-track, ripple delete, titles, export. Eleven of the twelve features asked for.
Servers, channels, invites and a voice call that survives closing the window. Published, then installed by someone else.
A 5.3 KB spec, one shot: four-column shell, roles, hover actions, context menus and a ⌘K switcher.
Files, windows, the tray, the microphone. An app can hold the background so a call keeps running after you close its window.
Own origin, own storage, no Node, no network unless you granted it. The permission list is on the app's page before you install.
Accounts, spaces, messages, documents, files and calls arrive as one API — and the platform pays for them while the app is small.
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.
No. Forge drives the Claude Code CLI you already have. There is no API client anywhere in it, and no key to leak.
The app carries on exactly as it did. Its backend bill moves from the platform to you, and you are told before that happens.
On your machine, in a git repository per app. Publishing uploads a built bundle; it does not take your workspace.
Only if you granted it that, at install, from a list you saw. Apps get their own origin, their own storage and no Node.
Forge has no model of its own and no training pipeline. Whatever applies to your Claude Code subscription is what applies.
Export an app as a standalone Electron project and it runs without Forge. Self-hosting the cloud is one compose file.
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.
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
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.
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.
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));
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();
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');
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.