The local-first software landscape — what’s actually shipping in 2026

"Local-first software" describes applications where the local copy of your data is canonical and cloud sync is an optimization rather than a dependency. The category was named in a 2019 essay by researchers at Ink & Switch, then sat dormant for years while the underlying CRDTs matured in obscure libraries — until around 2024, when Yjs became a quiet default for collaboration features, Automerge 2.0 shipped a usable Rust core, and at least a half-dozen sync engines reached production. This page surveys what local-first looks like in practice in 2026: the working CRDT libraries beneath the stack, the sync engines competing to be the "Firebase for local-first apps," the consumer applications actually shipping the architecture, and the people whose writing is shaping where the category goes next. One deliberate omission: the Solid Project (Tim Berners-Lee's data-portability initiative) shares ambitions with local-first but operates at a different conceptual layer and would muddy the taxonomy below.

A survey of the data structures, sync engines, and shipping apps making local-first software practical in 2026.

software

CRDT libraries — the data-structure layer

  • Yjs
    The most widely deployed CRDT library, originally designed for collaborative text. If you're embedding live multi-user editing in 2026, Yjs is the unspoken default — Notion's collaborative cursors, Linear's real-time presence, and dozens of YC-stage startups all reach for it before considering alternatives.
    webpage
  • Automerge
    The CRDT library that started the local-first conversation. The 2.0 rewrite (2023) moved the core to Rust, finally making it performant for production document-shaped data. Weaker than Yjs for streams of text edits; stronger for nested JSON-like state.
    webpage
  • Loro
    A newer Rust-native CRDT library aiming to be faster than Automerge with cleaner text-editing semantics. Still in 'credible alternative' territory rather than default — but the benchmarks are real and the team ships consistently.
    webpage
  • Diamond Types
    Joseph Gentle's memory-efficient CRDT optimized for plain-text editing. Famously frugal — fits years of edit history for a large document into a few megabytes. Used inside Braid experiments and several Ink & Switch prototypes.
    webpage
  • cr-sqlite
    Not a CRDT library exactly — a SQLite extension that turns ordinary tables into CRDTs. The pragmatic option when your data model is already relational and rewriting around documents would cost more than it buys.
    webpage

Sync engines — the "Firebase for local-first" tier

  • Liveblocks
    Hosted collaborative-state-as-a-service with strong Yjs interop. The easiest path to 'real-time multi-user' if you can accept the vendor dependency and per-seat pricing. Best for design tools and editors; weaker for general apps.
    webpage
  • Replicache
    Aaron Boodman's sync engine that pioneered the client-view-plus-mutator pattern adopted by Linear. Now superseded by Zero from the same team, but Replicache is still in production at scale and worth studying as a model.
    webpage
  • ElectricSQL
    Postgres-backed sync with partial replication and conflict-free updates. The closest thing to a 'Firebase for relational local-first apps' — keep your schema in Postgres, get offline-first clients more or less for free.
    webpage
  • Zero
    Replicache's successor from the Rocicorp team. Reactive query engine, very fast initial loads, focus on developer ergonomics. The 2025–2026 frontrunner if DX is what decides the category.
    webpage
  • Triplit
    Schema-driven local-first sync with end-to-end TypeScript types. Younger entrant betting on developer experience over raw scale. Worth a long look if you're a TypeScript shop and your data fits a relational model.
    webpage

Apps actually shipping local-first

  • Linear
    The most successful production local-first app. Pioneered the playbook of 'your client holds the canonical state; the server exists for sync and collaboration.' The reason serious founders now take this architecture seriously.
    webpage
  • Tana
    Outliner-PKM with a local-first sync model. Worth studying for how it handles eventual consistency in an interactive UI — edits never block on the network, but conflict resolution stays visible to the user rather than hidden inside the engine.
    webpage
  • Reflect
    Local-first notes app built explicitly on Replicache. A clean case study in what the architecture buys end-users: instant load, true offline, full sync without spinners. Smaller scope than Obsidian; better polish.
    webpage
  • Excalidraw
    Open-source whiteboard with Yjs-backed collaboration. Demonstrates how far local-first can be pushed by a tiny team — fully offline, real-time when online, and hackable enough to be self-hosted with five lines of config.
    webpage
  • Reactive
    Local-first project tracker; effectively a clean-room implementation of the Linear playbook for a different audience. Smaller, faster, and more opinionated than Linear about what 'small team' means.
    webpage

Thinkers & further reading

  • Local-First Software: You Own Your Data, in Spite of the Cloud
    The 2019 essay that named the category. Still the best single starting point — sets out the seven properties of local-first software and why the prevailing cloud model fails them. Read this before reading anything else in this folder.
    webpage
  • Local-First Web
    Community hub: conference talks, discussion archive, and the ongoing list of working libraries and apps. The closest thing the movement has to a canonical reference site — use it as a quarterly checkpoint.
    webpage
  • Ink & Switch research
    The research lab whose work seeded most of the modern local-first stack. Read their essays in chronological order — the through-line from Patchwork to Cambria to Beehive is the intellectual history of this whole space.
    webpage
  • Geoffrey Litt's blog
    One of the original local-first essay's co-authors. Argues for 'tools for thought + local-first' as a single intellectual project. His Riffle and Potluck essays are essential.
    webpage
  • Martin Kleppmann — 'Local-First Software' (Strange Loop talk)
    Kleppmann's 45-minute Strange Loop talk introducing local-first software to a working-programmer audience. The clearest single-medium explanation of what the category is and why it matters. Watch this if a stack of essays feels like too much.
    video