Rustpad

Self-hosted real-time code collaboration, honestly reviewed. No marketing fluff, just what you get when you run it yourself.

TL;DR

• What it is: Open-source (MIT) collaborative code editor powered by Rust, React, and WebAssembly. Multiple people edit the same file in a browser simultaneously, no accounts required [README].
• Who it’s for: Developers who need a fast, disposable shared scratchpad — for coding interviews, pair programming sessions, or quick cross-team snippets. Not a full IDE replacement [2][4].
• Cost savings: CoderPad and CodeInterview used to offer free no-login trials; those have largely shut down [2]. Rustpad self-hosted on a $5/mo VPS gives you the same frictionless shared-pad experience at zero recurring cost.
• Key strength: 6 MB Docker image, no database required, deploys in under five minutes. The Monaco editor frontend means it looks and feels exactly like VS Code [README][4].
• Key weakness: Documents are ephemeral by default — lost after 24 hours of inactivity or a server restart unless you wire up optional SQLite. No authentication, no persistent workspaces, no code execution out of the box [README][2].

---

What is Rustpad

Rustpad is a minimal collaborative text editor that runs entirely in the browser. You open a URL, share it with a colleague, and you’re both editing the same file in real time — no login, no plugin install, no account. That’s the whole pitch.

The technical stack is more interesting than the feature list suggests. The backend is written in Rust using the warp web server framework and implements the operational transformation algorithm to reconcile simultaneous edits from multiple clients [README]. The frontend uses React and Monaco — the same editor engine that powers VS Code — so syntax highlighting, keyboard shortcuts, and the general feel are immediately familiar to anyone who’s used a modern IDE [README][5]. The text operation logic itself is compiled to WebAssembly and runs client-side, which is why latency feels low even over slow connections [README][4]. All communication happens over WebSocket [README].

The project was created by Eric Zhang, who also built bore (a simple tunnel tool) and sshx (browser-based terminal sharing). The Rustpad approach fits the same pattern: small, composable, ruthlessly focused on one thing [4].

As of this review it sits at 3,983 GitHub stars. It hit Hacker News front page on June 5, 2021, and appeared on Reddit’s r/rust and r/programming the same day [README]. Growth has been moderate since — this is not a hyped project, which is actually a good sign for something you want to quietly run forever on a VPS.

---

Why people choose it

The clearest case for Rustpad comes from a developer who forked it to build a coding interview tool [2]. The problem: every existing solution required either installing a plugin (VS Code Live Share, JetBrains Code With Me), creating a platform account (Floobits), or paying for SaaS (CoderPad, CodeInterview). When those SaaS free tiers disappeared, the author went looking for a self-hosted alternative. Rustpad was the closest thing — a browser-native shared editor that candidates could open with zero setup and zero familiarity bias [2].

The author’s summary of why Rustpad works in that context: “Familiarity: the web editor is a ‘modern’ vanilla experience so most candidates got accustomed either immediately or very quickly. Security: all our personal files are well away from the web interface.” [2]

A French developer overview [4] frames it differently but lands in the same place: Rustpad wins on the combination of Monaco UI (zero learning curve for VS Code users), no database complexity, and Docker image size (6 MB, versus tools that ship dozens of dependencies). The 24-hour document lifespan is a feature for transient use cases, not a bug — you don’t accumulate stale pads.

The developer who cited it in a tools roundup [5] called it out specifically as “an online collaborative code editor that looks like VS Code — self-hosted, powered by Rust, TypeScript, and WebAssembly” — which is a useful one-sentence summary of why it attracts VS Code users who want collaboration without leaving the browser [5].

---

Features

Based on the README and article descriptions:

Core editing:

• Real-time collaborative editing via WebSocket, with operational transformation handling conflict resolution [README][4]
• Monaco editor frontend — syntax highlighting, multiple language modes, familiar VS Code keybindings [README][5]
• WebAssembly-compiled text operation logic runs in the browser [README]
• No login, no account — share a URL and collaborators join immediately [2][4]

Storage and persistence:

• Default: in-memory only, documents expire after 24 hours of inactivity and are lost on server restart [README]
• Optional: set SQLITE_URI environment variable to enable SQLite snapshot persistence — documents survive restarts and are retained past the in-memory expiry [README]
• EXPIRY_DAYS variable controls how long inactive documents are kept (default: 1 day) [README]

Configuration:

• PORT — which port to listen on (default: 3030) [README]
• RUST_LOG — logging directive control [README]
• Multi-platform Docker image: linux/amd64 and linux/arm64 [README]

What it doesn’t do:

• No code execution — you edit code, you don’t run it [2]
• No user auth, no access control, no private pads
• No version history UI (documents are snapshots, not commits)
• No chat, no annotations, no review comments

The fork described in [2] added remote execution via the Piston backend — supporting Python, JavaScript, Rust, and other languages — which plugs the biggest gap for interview/scratchpad use cases. The base Rustpad doesn’t include this; you’d have to self-integrate [2].

---

Pricing: SaaS vs self-hosted math

Rustpad has no SaaS tier and no commercial license. It is MIT, free to use, free to fork, free to embed in your own product.

Self-hosted cost:

• Software: $0 [README]
• VPS to run it: $4–6/mo on Hetzner or Contabo (the 6 MB image runs fine on the smallest instances)
• Optional domain + reverse proxy: depends on your existing setup

What you’d pay for alternatives:

CoderPad’s current paid plans are not publicly listed with specific prices in the source material, but the developer in [2] notes that the free no-login trials that used to cover casual interview use cases have been shut down — meaning you now need a paid account for what used to be free. The author’s conclusion was that self-hosting Rustpad was a better deal specifically because it required no recurring commitment for occasional use [2].

VS Code Live Share is free but requires a GitHub or Microsoft account, the Live Share extension, and VS Code itself — not zero-friction for a candidate joining an interview [2].

Concrete math for a developer doing technical interviews: If you run 20 interviews per month on a paid CoderPad plan, you’re paying a monthly subscription for software that runs on someone else’s server and stores your interview sessions externally. Rustpad self-hosted on a $5 VPS costs $60/year with no per-interview limit and your data stays on your infrastructure. For teams with higher interview volume, the difference compounds.

---

Deployment reality check

This is where Rustpad genuinely earns its reputation. The Docker path is:

docker pull ekzhang/rustpad
docker run --rm -dp 3030:3030 ekzhang/rustpad

Open http://localhost:3030. Done. That’s a realistic five-minute deploy for anyone with Docker installed [README][4].

For production use with a domain and HTTPS, add a reverse proxy (Caddy handles TLS automatically in two lines of config). For persistence, mount a volume and pass the SQLite URI:

docker run -d \
  -e EXPIRY_DAYS=7 \
  -e SQLITE_URI=/data/rustpad.db \
  -v /local/path:/data \
  -p 3030:3030 \
  ekzhang/rustpad

[4]

What you actually need:

• A Linux VPS with 256 MB RAM or more (the 6 MB image is not a marketing lie — it is genuinely tiny) [README][4]
• Docker
• A reverse proxy if you want HTTPS (Caddy, nginx, Traefik)
• A mounted volume if you want documents to survive restarts

What can go sideways:

• The in-memory default catches first-time deployers off guard. If you restart the container without configuring SQLite, everything is gone. This is documented but easy to miss [README].
• No auth layer means anyone who finds the URL can edit the document. Fine for interview use cases, problematic if you’re running a shared instance on a public subdomain without thinking about it [2].
• The public instance at rustpad.io runs on Fly.io — if you want the data guarantee of self-hosting, you need to deploy your own; don’t mistake the demo for a production-grade free tier [README].

Realistic time for a technical user: 10–20 minutes to a working HTTPS instance. No surprises.

---

Pros and cons

Pros

• 6 MB Docker image, no database required by default. This is not an exaggeration. The operational transformation state lives in memory, and the optional SQLite path is additive, not mandatory [README][4].
• Monaco frontend. Candidates and colleagues don’t need to learn a new editor. If they use VS Code — or have seen anyone use VS Code — the interface is immediately familiar [README][5].
• Zero-friction join. No account, no plugin, no invite email. Share a URL, done. For coding interviews this matters enormously — the author in [2] explicitly picked Rustpad over Live Share and Code With Me because of this.
• MIT license. Self-host, fork, embed in your product. No commercial agreement, no “fair-code” restrictions, no lawyers [README].
• Genuinely minimal. No feature bloat. The tool does one thing well and doesn’t accumulate settings panels.
• Multi-platform Docker support. Works on ARM64 — runs fine on a Raspberry Pi or Apple Silicon Mac [README].
• Forkable architecture. The codebase is small enough to understand and extend. The [2] developer added Piston-based remote execution in a reasonable amount of time [2].

Cons

• Ephemeral by default. Documents vanish after 24 hours or on restart without SQLite configured. For anything longer than a session, this is a footgun [README].
• No authentication. There’s no concept of a private pad, user accounts, or access control. Anyone with the URL can edit [2].
• No code execution. For interview and scratchpad use cases, this is the most common missing feature. You’ll need to fork and integrate Piston (or another execution backend) to run code [2].
• Low recent activity. With 3,983 stars and no visible recent commit data in the source material, this is not an actively maintained project the way n8n or Activepieces are. If something breaks with a new Rust version or Docker base image, you may be waiting a while for a fix.
• No team features. No persistent workspaces, no history UI, no presence indicators beyond cursor position.
• Not a general notes/writing tool. One reviewer comparing lightweight editors [3] found it unsuitable for their use case (personal text files across devices) precisely because it lacks persistence and file management. Rustpad is a scratchpad, not a notepad.

---

Who should use this / who shouldn’t

Use Rustpad if:

• You run technical interviews and want a zero-setup shared editor that candidates can join from a URL with no friction.
• You pair-program occasionally and want something faster to spin up than VS Code Live Share.
• You want a Monaco-based scratchpad for quick cross-team code reviews that doesn’t require everyone to install anything.
• You’re comfortable deploying Docker and want a genuinely tiny operational footprint.
• You want to fork it — the codebase is small and well-structured enough to build on [2].

Skip it if:

• You need documents to persist reliably without extra SQLite setup.
• You need access control or private pads.
• You need to run code, not just write it (look at the Piston-integrated fork [2] or CoderPad alternatives instead).
• You’re looking for a personal text editor or notes tool across devices — a reviewer testing editors for ChromeOS [3] would find Rustpad fundamentally unsuitable because it doesn’t manage files.
• You need a full collaborative IDE with version history, comments, and team management — VS Code Live Share or Gitpod are more appropriate.

---

Alternatives worth considering

• VS Code Live Share — free, deeply integrated with VS Code, includes voice chat and shared terminals. Requires the Live Share extension and a GitHub/Microsoft account — the friction that sends some users to Rustpad instead [2].
• CoderPad / CodeInterview — the SaaS alternatives Rustpad replaces for interview use cases. Better UX polish and built-in code execution, but paid and third-party-hosted [2].
• Etherpad — older open-source collaborative editor. More features (chat, history), but heavier and needs a database. Syntax highlighting is weak compared to Monaco [3].
• Hedgedoc — collaborative Markdown editor with persistent notes and accounts. Different use case (docs/writing vs code) but worth knowing if you need persistence.
• Piston fork of Rustpad — the fork described in [2] adds multi-language remote code execution to the base Rustpad. If you need that capability and can maintain a fork, it solves the biggest gap without switching to a full SaaS.
• Gitpod / GitHub Codespaces — full cloud dev environments with persistence, terminals, and extensions. Overkill for quick collaboration, but the right tool for onboarding contractors to an existing codebase.

For the specific use case of disposable real-time code collaboration without accounts, Rustpad has no self-hosted equivalent that matches its operational simplicity. The choice is usually Rustpad (minimal, forkable, no database) versus Etherpad (heavier, more features, still no Monaco).

---

Bottom line

Rustpad is the kind of tool that earns its stars through restraint. It does one narrow thing — real-time collaborative code editing in a browser — and does it with a 6 MB Docker image and no external dependencies. The Monaco frontend means anyone who uses VS Code is immediately at home. The no-account-required join flow means it works for coding interviews, pair programming sessions, and quick reviews without any coordination overhead.

The trade-offs are real and documented: documents are ephemeral unless you configure SQLite, there’s no auth layer, and there’s no code execution. If those gaps matter for your use case, you’re either extending the project yourself [2] or paying for a SaaS alternative that’s since stopped offering free tiers.

For a developer who needs a disposable shared scratchpad and would rather pay $5/mo for a VPS than sign up for another SaaS, Rustpad is a reliable, low-maintenance answer. Set it up once, forget it’s running, share URLs when you need them.

---

Sources

1. Medevel — “11 Open-source Free Self-hosted Web-based Code Editor for Teams and Agencies”. https://medevel.com/11-self-hosted-code-editors-os/
2. Gagbo.net — “Forking Rustpad to create a lightweight coderpad clone” (July 22, 2022). https://gagbo.net/post/forking-rustpad/
3. Dom Corriveau, blog.ctms.me — “Notes - Self-hosting VSCode code-server and researching various text editors” (April 1, 2025). https://blog.ctms.me/posts/2025-04-01-notes-code-server/
4. La Vedette — “L’éditeur de code que vos collègues vous cache pour garder l’avantage”. https://lavedette.net/lediteur-de-code-que-vos-collegues-vous-cache-pour-garder-lavantage/
5. Develovers.de — “Tools — Develovers”. https://develovers.de/tag/tools/

Primary sources:

• GitHub repository and README: https://github.com/ekzhang/rustpad (3,983 stars, MIT license)
• Official public instance: https://rustpad.io
• Docker Hub image: https://hub.docker.com/r/ekzhang/rustpad