doop logo

doop

The open-source alternative to Paper.design. A multiplayer design canvas where humans and AI agents design together, live. MCP built in.

cloud doop.designPRs welcome
Website GitHub

What is it?

What it is

Doop is an open-source, multiplayer design canvas (built in TypeScript) for humans and AI agents to design together in real time. It is positioned as the open-source alternative to Paper.design. Canvases contain Frames — artboards that render real HTML inside sandboxed iframes — and are edited live in the browser by humans and over a built-in MCP server by agents (e.g. Claude Code).

Why it exists

Existing design tools split humans and AI into a prompt-and-refresh loop, and the closed-source market leader (Paper.design) has no open counterpart. Doop exists to let humans and AI agents collaborate on the same canvas with true live multiplayer — shared cursors, presence, streaming edits, and an activity feed — while remaining self-hostable in a single command (docker compose up, or bun run dev with embedded Postgres).

Who should use it

Designers, developers, AI agents, product teams, and self‑hosted enthusiasts who want real‑time collaborative design with AI assistance.

Who should avoid it

Users looking for a fully hosted, no‑setup solution without technical configuration, or those who need a closed‑source, proprietary tool.

Stars over time

+16 stars in the last 1 day

524508
Aug 30, 2026Aug 31, 2026

How it works

A quick walkthrough in plain English

How doop works

Step 1 of 3

You interact with it

Open doop, send a request, or connect it to your stack.

Features

Multiplayer design canvas supporting both humans and AI agents
Frames that render real HTML in sandboxed iframes
Built-in MCP server for AI agent integration
Claude Code and MCP client connection via OAuth
Built-in Doop Agent for server-side design automation
Live cursors, presence indicators, and per-frame editing badges
Activity feed tracking all canvas changes
Undo/redo and comments pinned to elements
Design memory with exemplar frames and style rule distillation
Private-by-default canvases with email invite and link sharing
Self-hosting with Docker or single command (bun run dev)
Embedded Postgres (PGlite) requiring no external services
doop-sync.js snippet for importing live app screens as frames
Typewriter reveal for streamed agent designs
Feedback system for steering agent tasks
Frame screenshots via Puppeteer for agent review cycles
Infinite canvas with pan/zoom and dot grid
REST API equivalent for all MCP tools
Real-time WebSocket collaboration per canvas
Admin panel with read-only "view as" sessions

Advantages

  • Open-source alternative to Paper.design under AGPL-3.0
  • Enables real-time human-AI collaborative design workflows
  • Multiple AI paths: Doop Agent on server key, Doop Agent on user key, or external MCP clients
  • Zero-configuration local development with embedded database
  • One-command Docker deployment for production
  • Granular access control with private canvases and role-based permissions
  • Free tier for Doop Agent lets users try before connecting their own account
  • Streaming designs let humans watch AI agents work live
  • Built-in guideline distiller proposes durable style rules from canvas
  • Screenshots allow agents to see and iterate on their own designs
  • Built-in screenshot renderer accessible via REST endpoint
  • MCP OAuth flow connects any MCP client in one command
  • Activity feed and presence provide full audit trail
  • ChatGPT subscription and API key paths for user-connected agents
  • Multi-provider support: Anthropic, Azure OpenAI, OpenAI
  • Graceful degradation when optional integrations (SMTP, object storage) are not configured
  • Scripts stripped and inputs redacted in frame imports for security

Disadvantages

  • AGPL-3.0 license requires publishing source changes if modified version is offered as service
  • Doop name and logo are trademarks not covered by the code license
  • ChatGPT subscription integration may violate OpenAI terms; heavy use risks rate-limiting or suspension
  • Self-hosting requires managing infrastructure, database persistence, and API keys
  • PGlite embedded database only suits single-instance deployments with persistent volumes
  • Azure OpenAI cannot be user-connected due to SSRF security concerns
  • SMTP signup/reset hangs on hosts blocking outbound ports 25/465/587 (Resend ports 2465/2587 are workaround)
  • Admin role promotion requires SMTP for email verification in production
  • No "unlimited" value for RESIDENT_TASK_LIMIT; self-hosters must set large number
  • Device code authorization for ChatGPT must be enabled in workspace settings
  • gpt-5.4 models retire August 31 2026; pinning via env var breaks subscription path
  • Canvas URL sharing exposes canvas IDs; link sharing grants edit access to anyone with link

Installation

cloud

doop.design

docker

docker build -t doop . && docker run -p 4400:4400 -e BETTER_AUTH_URL=http://localhost:4400 -e BETTER_AUTH_SECRET=dev-only doop

native

bun install && bun run dev

compose

BETTER_AUTH_SECRET=$(openssl rand -hex 32) docker compose up -d   # app + Postgres on :4400

FAQ

How do I start a local development instance of Doop?

Clone the repo, install dependencies with `bun install`, then run `bun run dev`. This starts the web app on `http://localhost:4300` and the API/WebSocket/MCP server on `http://localhost:4400`. Data is persisted to an embedded Postgres in `data/pg` with no extra configuration required.

How do I connect Claude Code (or any MCP client) to a canvas?

Use the MCP OAuth flow: run `claude mcp add --transport http doop http://localhost:4300/mcp`. A browser window opens, you approve, and the client stores a bearer token. The agent then works under your identity, streaming designs live on the canvas you specify.

What is the built-in Doop Agent and how do I enable it?

The Doop Agent is a server‑side design team that can queue work, @mention roles, and produce designs without a human in the loop. Enable it by setting `ANTHROPIC_API_KEY` (or `DOOP_AGENT_PROVIDER=azure` with Azure OpenAI env vars) in `.env`. The free tier gives you a few tasks per account before you need to connect your own model account.

How does multiplayer collaboration work in Doop?

Doop uses a per‑canvas WebSocket room for true multiplayer: live cursors with name tags, presence avatars, per‑frame editing indicators, colored flashes on remote edits, undo/redo, comments pinned to elements, and an activity feed that logs every create/edit/rename/delete by user or agent. Everything is server‑authoritative and auto‑reconnects.

How do I share a canvas with collaborators?

Canvases are private by default. Use the Share modal to invite collaborators by email or toggle link sharing, which creates a shareable URL anyone with the link can edit. Agents connected over MCP inherit the same access as the user who approved them.

How do I self‑host Doop in production?

You can deploy with Docker: `BETTER_AUTH_SECRET=$(openssl rand -hex 32) docker compose up -d`. For production, also set `DATABASE_URL` (managed Postgres), `BETTER_AUTH_URL` (public origin), and any optional integrations (SMTP, object storage, etc.). Health check is `GET /healthz`. Alternatively, build and run `bun run build && bun run start` on a single server.

Loading documentation…
View on GitHub

Featured in Videos

YouTube tutorials and walkthroughs for doop

Alternatives

Similar projects ranked by category, topics, and text overlap.

Compare
doop | MushyBook