Google Docs for Markdown: real-time collaboration without leaving plain text

For two decades, the trade-off was simple. If you wanted real-time collaboration, you used Google Docs. If you wanted plain text — files you owned, version-controlled, grep-able, future-proof — you used markdown. You couldn't have both.

MarkdownSync exists to close that gap. Live multi-cursor editing, comments, cursor presence, the works — on top of plain markdown that lives in your browser first and on disk forever.

The core idea is simple:

Your notes live on your device first. You can go fully offline (plane, bad WiFi, whatever), keep editing, and when you’re back online everything syncs automatically. If you share a doc, other people see updates pretty much instantly.

Why I built it:

Most tools I’ve used treat the server as the source of truth. That never sat right with me for personal notes. I wanted something where:

• my data stays local
• offline actually works properly
• collaboration isn’t an afterthought

What it does:

• Fully offline editing (no connection needed at all)
• Syncs changes once you reconnect
• Real-time collaboration (even if two people edit the same line, it doesn’t break)
• Plain Markdown (no lock-in, easy to export)
• WYSIWYG + source mode toggle
• Everything stored locally in your browser (IndexedDB), including unsynced changes

Why "Google Docs for Markdown" is the right comparison

Google Docs got three things right that the rest of the industry is still catching up on:

1. You don't think about saving. The document is always saved. The act of writing is the act of persisting.
2. You don't think about sharing. Send a link, and the other person is editing alongside you within seconds.
3. You don't think about merging. Two people typing in the same paragraph just works. No conflicts, no "their version vs. yours."

Markdown editors got one thing right that Google Docs never did:

• Your writing is text. Not XML inside a binary blob. Not a proprietary structure that requires their servers to parse. A .md file you can open in Vim in 2046.

MarkdownSync is the first category that takes both seriously.

What "real-time" actually means here

A lot of "collaborative" markdown editors are really just "shared" — they save to a server, and the next time someone opens it, they see the latest version. That's not collaboration. That's a shared folder.

In MarkdownSync, when your collaborator types a character, it appears in your document in the next frame. Their cursor is visible. Their selection is visible. If you're both typing in the same sentence, both edits land — without one overwriting the other, without a "who wins" dialog.

The mechanism underneath is an Egwalker CRDT. Every keystroke is an operation with a stable ID and causal dependencies. The order of operations is deterministic regardless of which device sees them first, so two people on opposite sides of the planet converge on identical text without any central referee picking a winner.

The local-first part — where we go further than Google

Google Docs has one structural weakness: if Google's servers are down, or if your wifi drops, or if your account is locked, your document is gone. Not corrupted — gone. The file does not exist on your machine.

MarkdownSync flips that. Every document you open is mirrored to your browser's IndexedDB along with a durable outbox of unsent operations. If you go offline mid-flight, you keep editing. If your collaborator goes offline, they keep editing. When the network comes back, the outbox flushes in causal order and everyone catches up.

This is the difference between cloud-synced and local-first: the cloud is a relay, not the source of truth. Your machine is the source of truth.

What it feels like to use

If you've used a modern WYSIWYG editor, MarkdownSync will feel familiar within thirty seconds. Headings render as headings, lists as lists, tables as tables. Type # and the line becomes a heading. Type - [ ] and you get a checkbox.

If you've used a markdown editor before, the source-mode toggle will feel familiar too. The underlying file is plain text. You can copy it, paste it into a git repo, render it on GitHub, pipe it through pandoc.

The shortcuts you'd expect — Cmd+B, Cmd+I, Cmd+K for links — all work. The command palette (Cmd+K with no selection) lets you jump to a document, insert a table, change a heading level, or anything else without leaving the keyboard.

What it replaces

Teams have told us MarkdownSync replaces:

• Google Docs — for engineering RFCs, design specs, and anything that ends up in a git repo eventually anyway.
• Notion — for documents where the database features are overkill and the lock-in is a liability.
• HackMD / Dropbox Paper — for the same use case but with stronger offline support and CRDT-grade collaboration.
• A shared notes.md in a repo — for any pair or trio that's been emailing diffs at each other.

We don't think it replaces all of these for everyone. If your document is a database, use a database. If your document is a slide deck, use a slide tool. But if your document is prose with structure, MarkdownSync is what we wish had existed all along.

Try it

Open a document. Share the link with someone. Type at the same time. That's the entire onboarding.

Try it via MarkdownSync web app — or say hi on Discord and tell us what you'd want from the markdown editor of the next decade.