how it works

Every coin comes with an app you can open.

Most launchpads let anyone mint a ticker. On shipped you describe an app and frontier AI models build it in front of you. When you're ready, give it a coin and it lives here, next to its chart.

the flow

From a sentence to a live, tradable app.

Five steps. One signature. No code, no deploy.

  1. 01

    Describe it

    Type the app you want or drop a screenshot of something you like. Pick a model. Nothing is written yet.

  2. 02

    Launch a coin (optional)

    When you like what you built, give it a pump.fun coin. The AI suggests a name, ticker and icon; you edit them and approve once. You are the creator, so creator fees go to your wallet.

  3. 03

    We check the bytes

    Before relaying, the server re-checks the signed transaction: fee payer is you, the mint co-signed, and every instruction matches what we built. Anything modified is refused.

  4. 04

    Watch it get built

    The moment the coin lands, the AI writes the app live in the studio. It is hosted instantly at its own URL, and that URL is the coin’s website.

  5. 05

    Keep shipping

    Iterate with prompts, fix errors with one click, restore any version. Every change ships to the same URL, and the coin page shows the live app next to its chart.

how the AI works

A real build pipeline, not a chat box.

Your prompt is wrapped in a strict builder brief, routed through Vercel AI Gateway to the model you chose, and streamed back live. Nothing reaches your app URL until it is a complete, working document.

  1. 01Your promptText, plus an optional screenshot and your last 6 prompts.
  2. 02Builder briefStrict output rules, a quality bar and the shipped SDK reference.
  3. 03AI GatewayVercel AI Gateway routes the request to the model you picked.
  4. 04Model streamsHTML arrives token by token. Cut off? It continues, up to 3 passes.
  5. 05Checked + savedOnly a complete document is saved as a new version. Never half a page.
  6. 06Live at its URLHosted sandboxed at /p/id, which is also the coin’s website.
  • One file, every time

    Models are briefed to return a single self-contained HTML document. That is why every app can be hosted, downloaded, sandboxed and remixed.

  • Never half a page

    Long apps can outgrow one response. The builder detects a cut-off file and asks the model to continue, up to three passes, before saving.

  • Sees what you see

    Drop a screenshot and a vision model builds from it. Picked a text-only model? The turn is handed to one that can read images.

  • Fixes its own bugs

    The studio preview catches runtime errors inside your app. One click sends the real error messages back to the model.

You write this

prompt
A tiny space shooter.
- Arrow keys or drag to move, auto-fire
- Enemies speed up every 20 seconds
- Neon on black, chunky pixel font
- Global leaderboard: ask for a name once, show the top 10

The model is briefed with this

builder brief (excerpt)
You are the app builder inside "shipped". You turn a user's idea
into ONE complete, working, beautiful web app delivered as a single
self-contained HTML file.

Output rules (strict):
- Reply with ONLY the HTML document, starting with <!doctype html>.
- Everything lives in this one file: markup, <style> and <script>.
- You MAY load Tailwind, Google Fonts, and libraries from jsdelivr/unpkg.
- Never use external images. Draw with CSS, inline SVG or canvas.
- The app MUST work immediately with no setup, no API keys.

Built-in cloud SDK (already loaded as window.shipped):
- shipped.db.get / set / incr / list   shared by every visitor
- shipped.scores.submit / top          global leaderboards
- shipped.coin(wallet?)                live coin + holder check

And this is what ships

<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8" />
  <meta name="viewport" content="width=device-width, initial-scale=1" />
  <title>Star Dash</title>
  <script src="https://cdn.tailwindcss.com"></script>
</head>
<body class="bg-black text-white">
  <canvas id="game" class="block h-dvh w-full"></canvas>
  <ol id="board" class="fixed right-4 top-4 font-mono text-sm"></ol>
  <script>
    async function gameOver(score) {
      if (!window.shipped) return
      const name = localStorage.getItem('pilot') || prompt('Pilot name?') || 'anon'
      localStorage.setItem('pilot', name)
      const { rank } = await shipped.scores.submit(name, score)
      const top = await shipped.scores.top({ limit: 10 })
      board.innerHTML = top
        .map((r) => `<li class="${r.me ? 'text-green-300' : ''}">#${r.rank} ${r.name} ${r.score}</li>`)
        .join('')
    }
    // ...game loop
  </script>
</body>
</html>

the models

Pick the brain for each prompt.

Models from four labs, one switch away in the studio. Mix them freely: draft fast, then polish with the strongest coder.

Model docs
  • Kimi K2.7 CodeMoonshot AI
    Default

    The default. Strongest at long, complete files: games, tools with real logic, careful layouts.

    moonshotai/kimi-k2.7-codespeedReads screenshots
  • Google DeepMind
    Gemini 2.5 FlashGoogle DeepMind

    Bold, playful visuals and reading screenshots. Great for "make it look like this".

    google/gemini-2.5-flashspeedReads screenshots
  • GPT-4.1 miniOpenAI

    Balanced and dependable. Clean structure, good at following detailed specs.

    openai/gpt-4.1-minispeed
  • Z.ai
    GLM 4.7 FlashZ.ai

    Quick drafts and small edits when you want to iterate fast.

    zai/glm-4.7-flashspeed
  • GPT-OSS 120BOpenAI

    Open-weight and the fastest of the set. Good for simple apps and rapid tweaks.

    openai/gpt-oss-120bspeed

built-in sdk

Every app gets a backend

Hosted apps load window.shipped automatically. The AI already knows it, so asking for “a global leaderboard” just works. Limits: 500 keys per app, 8 KB per value, 60 writes and 20 scores a minute per visitor.

Shared cloud storage

Every visitor reads and writes the same data. Guestbooks, polls, counters, shared canvases.

await shipped.db.set('poll:yes', 0)
await shipped.db.incr('poll:yes')
const votes = await shipped.db.get('poll:yes')
const notes = await shipped.db.list('guestbook:')

Global leaderboards

Each player keeps their best score. Use order "asc" for fastest-time boards.

const { rank } = await shipped.scores.submit('ava', 4200)
const top = await shipped.scores.top({ limit: 10 })
await shipped.scores.submit('ava', 9.81, {
  board: 'speedrun', order: 'asc',
})

Coin + holder check

Read the app coin’s live market cap, or check whether a wallet holds it.

const { coin } = await shipped.coin()
coin.marketCapUsd // 41250.12

const { holder } = await shipped.coin(wallet)
if (holder.holds) unlockGoldenMode()

faq

Questions

Still curious? The docs go deeper.

Which AI writes my app?

The one you pick. shipped offers models from Moonshot AI, Google, OpenAI and Z.ai, all routed through Vercel AI Gateway. Kimi K2.7 Code is the default because it writes the most complete files.

Who gets the creator fees?

You. The dev wallet that signs the launch is the coin’s creator on pump.fun, and pump.fun pays creator fees to it. shipped takes nothing.

Can I bring an app I built somewhere else?

No. shipped is for apps built here. That way every coin points at an app anyone can open, play and remix, and the version history is public.

Does my app need a backend?

No. Every hosted app gets window.shipped: shared storage, global leaderboards and live coin data, with no keys or setup.

Where does trading happen?

Right on the app page, from your own wallet. Coins are normal pump.fun coins, so they trade on the bonding curve and graduate like any other.

Who can edit my app?

Only you. Editing needs the private build key saved in your browser when you started the app. Anyone can remix it into their own copy, which then needs its own coin.

Your next app is one sentence away.