Rustpad

Last reviewed Sep 13, 2026 · 727 words

docker run -d -p 3030:3030 ekzhang/rustpad and you have a working Google Docs-style shared text editor, thirty seconds after reading this sentence. Rustpad is the smallest useful collaborative editor I know of: a single Rust binary, a Monaco-based editor in the browser, operational transformation for conflict-free simultaneous typing, and no database at all. It idles around the 64 MB the catalogue lists. It is also, by default, an editor whose documents vanish after a day, and understanding that is most of what there is to know.

What it is for

Rustpad is a scratchpad, not a document system. Open https://pad.example.com/ and you get a random document ID in the URL; send that URL to a colleague and you are both typing in the same buffer with live cursors, syntax highlighting for dozens of languages, and a Monaco editor that behaves like VS Code. There is no login, no user list beyond the coloured cursors and chosen names, and no formatting beyond plain text. MIT licensed, 4,075 stars, developed since 2021, the public demo at rustpad.io is the reference instance.

The everyday uses are narrow and real. Pairing on a config file over a call when screen sharing is too laggy. Pasting a stack trace for two people to annotate. Live-coding a snippet in an interview. A shared clipboard between a laptop and a phone on the same network. Anything where "we both need to edit this text for the next hour" is the whole requirement.

Documents are ephemeral unless you say otherwise

By default a document lives in server memory and is dropped after 24 hours of inactivity; a restart also loses everything. Two environment variables change that. EXPIRY_DAYS sets how long an idle document is kept, and SQLITE_URI points at a SQLite file so documents survive restarts:

services:
  rustpad:
    image: ekzhang/rustpad
    ports:
      - "3030:3030"
    environment:
      - SQLITE_URI=/data/rustpad.db
      - EXPIRY_DAYS=30
    volumes:
      - ./data:/data
    restart: unless-stopped

With that, a document at a URL you bookmarked will still be there next month. Without it, Rustpad is a whiteboard that gets wiped nightly, which is a feature if you mostly paste secrets and logs into it and a nasty surprise if you drafted something you cared about.

It has no authentication, so put a door on it

Anyone who can reach the server can create documents, and anyone who guesses or receives a URL can edit that document. The document IDs are random enough that guessing is not a practical concern, but the "anyone can reach it" part is. Do not expose Rustpad naked on the internet. Three sensible patterns: keep it on Tailscale so only your devices see it; put it behind Caddy with basic auth so a shared password gates the whole instance; or run it behind your identity provider's forward-auth proxy if you already have one. All three take under ten minutes. Rustpad speaks WebSocket for its sync channel, so make sure the proxy passes upgrades through, which Caddy does automatically.

When you want HedgeDoc or CryptPad instead

Rustpad is plain text. The moment you want headings, rendered markdown, images, a document list, permissions or revision history, it is the wrong tool. HedgeDoc is the standard for collaborative markdown with a proper rendered view and accounts. CryptPad is the end-to-end encrypted office suite when the content itself is sensitive and you want the server unable to read it. Etherpad is the older rich-text pad with a plugin ecosystem. All three are heavier by an order of magnitude and worth it for documents that are meant to last. For people leaving Google Docs, the Google Docs alternatives page maps the whole field; Rustpad is a footnote there and a first choice only for the scratch use.

What I'd do

Run Rustpad with SQLITE_URI set and EXPIRY_DAYS around 30, on a Tailscale-only hostname, and bookmark two or three fixed document URLs as standing shared scratch spaces. Pair it with HedgeDoc for anything that needs to look like a document. The whole Rustpad deployment costs less memory than a browser tab, and for the "we need to look at the same text right now" problem it is faster and less fussy than anything else built for group communication.