Yjs vs Automerge vs Liveblocks: CRDT Frameworks for Real-Time Apps in 2026

Every modern collaborative app, Notion, Figma, Linear, Miro, Loom, cursor sharing tools, you name it, runs on some form of conflict-free replicated data type (CRDT) or operational transformation (OT). In 2026, CRDTs have decisively won the architecture debate. The reason is not performance alone. It is that CRDTs make offline editing, branch-and-merge workflows, and decentralized sync practical without writing thousands of lines of conflict resolution logic yourself.

The elevator pitch: a CRDT is a data structure where any two replicas can be merged into a single consistent result, no matter the order of operations, without a central coordinator. That means two users can edit the same document offline, come back online, and the final state will be identical for both users. Traditional OT requires a server to transform operations. CRDTs do not. This matters enormously when you are thinking about scale, offline support, and architecture complexity.

The three frameworks that matter in 2026 are Yjs, Automerge, and Liveblocks. They overlap in what they do but they optimize for different things. Yjs is a low-level, high-performance CRDT library written in JavaScript that powers countless open-source collaboration tools. Automerge is the academic darling, now on its v2 rewrite, and focuses on rich document models and JSON-like structures. Liveblocks is a fully managed service that wraps Yjs (and now their own CRDT) in a cloud-hosted offering with presence, comments, and storage baked in.

Yjs, built and maintained by Kevin Jahns, is the fastest production-grade CRDT framework available. Benchmarks consistently show Yjs outperforming Automerge by 10x to 50x on large documents, with significantly smaller memory footprints. That performance gap is why Jupyter, Evernote, Sanity Studio, and dozens of other serious collaboration products use Yjs as their core collaboration engine.

The Yjs model is a set of shared types: Y.Text for collaborative text, Y.Array for lists, Y.Map for key-value data, Y.XmlElement and Y.XmlFragment for rich documents. You compose these into your document schema, and Yjs handles all the merge logic. For rich text editors, Yjs integrates with ProseMirror, Tiptap, Lexical, Slate, and Quill out of the box via official bindings. That ecosystem is the second-biggest reason to pick Yjs: you get editor integration for free.

What Yjs is not: a complete product. You have to pick your own transport (y-websocket, y-webrtc, y-indexeddb for local persistence), run your own backend for document storage and auth, and wire up presence and awareness yourself. The awareness protocol is built in but requires glue code on your side. If you are comfortable with the infrastructure work, this is a huge advantage. You control every tradeoff. If you are not, you will spend 6 to 10 weeks building the surrounding plumbing before you have anything to show users.

Yjs cost: free. Infrastructure cost depends entirely on your transport choice. A self-hosted y-websocket server on a small VPS costs $20 to $100 per month for the first 10,000 users. Our websockets guide covers the connection patterns you will want to use with Yjs.

Automerge has a different heritage. It started as a research project led by Martin Kleppmann at Cambridge, author of the landmark book on data-intensive applications, and the Automerge v2 rewrite (shipped in 2023) finally closed most of the performance gap with Yjs. Where Yjs focuses on minimal runtime cost, Automerge focuses on clean semantics and rich document models.

The signature feature of Automerge is its JSON-like API. You create an Automerge document, mutate it as if it were a plain JavaScript object, and the framework handles tracking the changes. That mental model is easier for teams coming from Redux or Immer than Yjs, where you must learn shared-type primitives. Automerge also has first-class support for branches and merges, which matters if you are building something closer to Git than to Google Docs. Version control for documents is a real product category in 2026, and Automerge is the only CRDT framework built for it out of the box.

Where Automerge loses is performance on very large documents and very high operation volumes. The v2 rewrite in Rust (with WebAssembly bindings) brought performance within 2x to 5x of Yjs for most workloads, but Yjs still wins in the top 10% of demanding use cases. Memory consumption is also still higher in Automerge. For documents under 10MB and sync events under 1K per minute, this gap is invisible. For heavy-duty editors, it is measurable.

Automerge is free and open source. Like Yjs, you bring your own transport and storage. Automerge Repo is the official storage and sync layer that the team added in 2024, and it makes the framework feel more batteries-included than Yjs without giving up control. That is the version I would pick for new projects that do not need absolute max performance.

Liveblocks wraps CRDTs in a commercial cloud service. You do not think about transports, storage, scaling, or presence. You install their SDK, define your room and storage schemas, and ship real-time features in a few hundred lines of code. In 2026 they support Yjs as their underlying CRDT plus their own proprietary Storage API, which is a simpler key-value CRDT for teams that do not need rich document editing.

What you get out of the box with Liveblocks: presence and awareness (cursor positions, user avatars), storage (persistent collaborative state), comments and threads, notifications, version history, and text editor bindings for Tiptap, Lexical, and ProseMirror. The developer experience is the best in the category. A productive team can ship Google Docs-like collaboration in a weekend instead of a month.

The tradeoff is cost and lock-in. Liveblocks pricing in 2026 starts free for up to 1,000 monthly active users, then jumps to $299 per month for 10,000 MAU, and enterprise plans for higher volume. The bandwidth and storage costs are bundled, which is a relief if you are not ready to operate your own sync infrastructure. The lock-in is real though. Migrating off Liveblocks means rebuilding your storage layer and your transport, which is multiple months of engineering for a mature app.

My rule of thumb: if you are shipping a v1 and need collaboration features but do not want them to be your core differentiator, use Liveblocks. If collaboration is the core of your product and you will iterate on it for years, invest in Yjs or Automerge and own the stack. Our collaboration tool build guide walks through this decision in more detail for Notion-style products.

Raw performance is the most misleading thing to compare because it depends on workload. Here is what actually matters for 2026 production apps, based on benchmarks and real customer data:

• Document load time: Yjs loads a 50K operation text document in about 40ms in modern browsers. Automerge v2 takes 80 to 120ms for the same workload. Liveblocks (backed by Yjs) matches Yjs performance but adds a network round trip.
• Memory footprint: Yjs uses roughly 2x the size of the raw text content. Automerge v2 uses 3x to 5x depending on history depth. Liveblocks performance matches its underlying engine.
• Operation throughput: Yjs comfortably handles 10K operations per second per document on commodity hardware. Automerge v2 hits 3K to 5K. For most apps you will never approach these numbers, but they matter for stress tests and pathological users.
• Garbage collection and compaction: Yjs compacts history aggressively and supports snapshot-based pruning. Automerge keeps full history by default, which is a feature for version-controlled documents but a cost for simple editing apps.
• Network efficiency: Yjs update messages are extremely compact (often under 50 bytes for a typing operation). Automerge v2 is within 2x of Yjs. Liveblocks adds a modest server-side protocol overhead.

For a real-world reference point: a Figma-scale multiplayer canvas with 20 simultaneous editors and 100K nodes would strain Automerge v2 and feel fine on Yjs. A Notion-scale collaborative document with 5 simultaneous editors and 50K tokens feels great on any of the three. If your worst-case workload is closer to Notion than Figma, you have more flexibility.

Offline support is where CRDTs shine and where framework choice matters most. All three handle offline editing correctly, but the persistence and sync stories differ.

Yjs has the richest persistence ecosystem. y-indexeddb stores documents locally in the browser with almost no configuration. y-leveldb and y-redis persist documents on the server. y-websocket handles WebSocket transport. y-webrtc enables peer-to-peer sync without a central server, which is fascinating for decentralized apps. Mixing and matching these providers is trivial. This flexibility is also the biggest downside: it is on you to pick the right combination and tune it.

Automerge Repo simplifies this. You configure storage adapters (in-memory, IndexedDB, Node.js filesystem, S3) and network adapters (WebSocket, BroadcastChannel for cross-tab sync) and the library orchestrates sync between peers. It is less flexible than Yjs but easier to reason about for a new team.

Liveblocks handles persistence entirely server-side. Your client keeps a local cache, but durable storage lives in Liveblocks' managed backend. Offline edits are queued and synced on reconnect, just like Yjs. The tradeoff is you cannot implement local-first patterns that avoid the Liveblocks server, because the server is always the source of truth for document storage.

For local-first architectures (apps that work entirely offline and sync to peers or servers when available), Yjs or Automerge are the only viable options. Liveblocks is a cloud-first service by design. Pick accordingly.

Here is the cleaner version of the decision tree I walk founders through in 2026.

• Pick Liveblocks if: you need to ship a v1 in under 8 weeks, collaboration is a feature rather than a core product, your team has no backend real-time experience, or you are happy paying for managed infrastructure. Best for SaaS dashboards with shared workspaces, collaborative forms, and Figma-style MVPs before scale matters.
• Pick Yjs if: you are building a serious collaborative editor as your core product, you want to minimize infrastructure cost at scale, you need first-class ProseMirror or Tiptap integration, or you want peer-to-peer transport as an option. Best for Notion or Google Docs alternatives, rich text editors, and anything where 10K+ monthly active users is a realistic goal.
• Pick Automerge if: your data model is document-centric with branching, you value developer experience over peak performance, or you are building something version-control-flavored like a git-for-documents product. Best for engineering teams with long-term product bets on collaboration and semantic data models.

A pragmatic 2026 playbook: prototype on Liveblocks to validate the feature fit with users in weeks, then migrate to self-hosted Yjs once you hit product-market fit and your collaboration usage crosses 2K monthly active users. Most teams never need to migrate because Liveblocks pricing is reasonable until you become a serious business, and by then you have the revenue to fund the migration if you choose to do it.

If you want a second opinion on your specific stack, data model, or scale requirements, Book a free strategy call and we will map out the CRDT decision against your roadmap and timeline.