Convex
by alexander-opalic
A reactive backend platform with built-in real-time sync, where server-side functions automatically push updates to connected clients.
sync-engines
(36)InstantDB
by alexander-opalic
A real-time, client-side database with relational queries and sync — offering a Firebase-like developer experience for local-first apps.
PowerSync
by alexander-opalic
A Postgres-based sync engine with offline support, designed for mobile and web apps that need reliable local-first data access.
Vibe Coding with Jazz
by anselm-eickhoff
A hands-on workshop building a multiplayer chat app with Jazz — demonstrating how local-first shared state replaces traditional backends, databases, and file storage with a single reactive abstraction.
CRDTs for Mortals
by james-long
You don't need a PhD to use CRDTs — a Last-Write-Wins Map plus a Grow-Only Set on top of SQLite gives you production-grade sync in 630 lines of JavaScript.
CRDTs: The Hard Parts
by martin-kleppmann
Martin Kleppmann goes beyond CRDT basics to explore the hard problems: interleaving anomalies in text editors, moving elements in lists and trees, and reducing metadata overhead — showing that CRDTs are easy to implement badly.
Talk Outline: Building Websites with Local-First and Vue
by alexander-opalic
Outline for a talk tracing the journey from manual DOM manipulation to reactive frameworks to offline-first to local-first, with practical Vue examples and sync engine comparisons.
Offline-First Apps with TanStack DB and PowerSync
by dev-agrawal
Most offline conflicts never happen in practice — non-overlapping writes and orthogonal field edits cover the majority of cases, so the real engineering challenge is choosing the right escalation strategy for the conflicts that do.
Sync Protocols and the Truth Behind Local-First
by tom-redman
Offline writes destroy serializability — it's a mathematical fact, not an engineering limitation. Reconciliation is a product design exercise, not a computer science problem, and you should start with strong consistency guarantees and intentionally weaken them.
Local-First Software
A comprehensive map of local-first software — from foundational philosophy and CRDTs to sync engines, tooling, and real-world production stories.
The Local-First Litmus Test: Real Examples Across the Spectrum
by alexander-opalic
Not everything that caches locally is local-first. The real test: does the app still work if the company disappears? A categorized directory of real apps across the spectrum.
The UX of Local-First
by eileen-wagner
The tech for local-first has matured but the UX hasn't — four unsolved design challenges stand between us and mainstream adoption, and they require collective agreement, not individual solutions.
SQLite Persistence on the Web
by conrad-hofmeyr
SQLite in the browser is already production-ready if you pick the right VFS — OPFS with synchronous access handles solved the persistence and sync/async impedance mismatch that held it back for years.
Sync Engines for Vue Developers
by alexander-opalic
Vue already syncs your refs to the DOM. Sync engines extend that same idea to databases — keeping client state and server state in harmony. Here's how Replicache, Zero, Convex, PowerSync, LiveStore, Jazz, and Dexie each approach this differently.
Sync Panel Discussion
by aaron-boodman, james-cowling, johannes-schickling, kyle-mathews
Four sync engine builders reveal that the real disagreement isn't sync vs. no-sync—it's where you draw the line between server authority and client autonomy, and every position demands different trade-offs.
Panel Discussion: The Big Questions of Local-First
by adam-wiggins, martin-kleppmann, aaron-boodman, peter-van-hardenberg
The original local-first essayists and a pragmatic sync-engine builder clash on whether offline writes should ship today or wait for version-control UX — revealing that the real fault line isn't technical but philosophical: who does the tool serve first?
Unleashing the Power of Sync
by dev-agrawal
Sync engines collapse distributed state management into straightforward SQL by maintaining local databases that sync bidirectionally, and this architecture extends naturally to AI agents that read and write directly to the database.
Building AI Agentic Apps in 2025
by sunil-pai
Every AI agent framework should be a sync engine—the pull-based architecture agents use today mirrors front-end evolution, and pushing data into agent context solves the fundamental performance problem of MCP tool fetching.
Local-First Software: Taking Back Control of Our Data
by cultrepo
Local-first isn't just offline capability—it's a paradigm shift where data lives on user devices by default, servers become optional infrastructure, and CRDTs enable collaboration without sacrificing ownership.
Native-Grade Web Apps with Local-First Data
by johannes-schickling
Web apps can rival native quality by replacing server-centric data architecture with client-side SQLite and automatic sync engines, eliminating loading states and enabling instant responsiveness
A Gentle Introduction to CRDTs
by matt-wonlaw
CRDTs let replicas update independently and merge automatically without conflicts
LiveStore
by johannes-schickling
A client-centric state management framework combining reactive SQLite with event sourcing and built-in sync, designed for high-performance local-first applications
The Past, Present, and Future of Local-First
by martin-kleppmann
Martin Kleppmann traces local-first from CRDTs to a proposed definition: software where another computer's availability never blocks the user—including when the developer shuts down.
Unexpected benefits of going local-first
by tuomas-artman
Beyond performance and offline support, local-first architecture dramatically improves developer productivity by eliminating network error handling and enabling synchronous data access.
UX++ and DX++ with Sync Engines
by carl-assmann
Sync engines remove network latency from the user interaction path by maintaining local data stores that sync bidirectionally with servers in the background.
A Tale of Two Sync Engines
by arushi-bandi
Not all data fits the CRDT model — Figma runs two sync engines because ephemeral state, derived data, and server-driven features each demand fundamentally different sync architectures, and scaling the non-CRDT one turned out to be the harder problem.
Can Sync Be Network-optional?
by brendan-obrien
Sync is literally impossible (we have a formal proof), centralization is faster (we have a paper), and the real prize of peer-to-peer isn't ideology — it's sublinear scaling, the same physics that makes electrical grids and cardiovascular systems work.
CRDTs Solved Conflicts, Not Sync
by adam-fish
CRDTs are a solid substrate for sync engines, but transport reliability, multiplexing, compression, query-based sync, and distributed deletes are the harder — and more valuable — engineering challenges.
General-purpose Sync with IVM
by aaron-boodman
Query-driven sync turns out to be the key to general-purpose sync engines — and the trick that makes it work at interactive speeds is a novel IVM approach (ZVM) that pulls sorted data through operator pipelines instead of pushing everything.
An Interactive Guide to TanStack DB
by maxi-ferreira
TanStack DB fixes what TanStack Query got wrong — isolated caches, boilerplate optimistic updates, and no data relationships — by adding collections, live queries, and transactional mutations that make sync engines a drop-in upgrade rather than a rewrite.
Sync Engines and Local Data
by wes-bos, scott-tolinski
Wes and Scott explore local-first sync engines — why they make apps feel fast, and how LiveStore, Zero, Instant DB, Convex, ElectricSQL, and PowerSync each approach the problem differently.
Conflict Resolution x Notion Blocks
by angelique-nehmzow
Notion's block model breaks every standard CRDT assumption — they had to invent text slices, text instances, and search labels to make conflict resolution work across a document editor where blocks constantly split, merge, and move.
An Object Sync Engine for Local-first Apps
by sujay-jayakar
The object sync engine — three components (local store, server store, sync protocol) wired together with server authority — is the architecture Linear, Figma, and Asana independently converged on. Convex is building their version.
A Map of Sync
by sujay-jayakar
The sync ecosystem is a wilderness — nine dimensions (size, update rate, structure, latency, offline, concurrency, centralization, flexibility, consistency) map where every platform sits and why no single engine wins everywhere.
The why and how of building a local-first music app
by johannes-schickling
Building a native-quality music app in the browser requires treating the web as a game engine problem — custom schedulers, canvas rendering, and event-sourced SQLite replace the standard toolkit when you refuse to accept spinners.
Powering Offline-First Forestry in Europe's Wilds
by alexander-thiele
When your users spend entire days in forests with zero connectivity, local-first isn't a nice-to-have — it's the only architecture that works. OCELL's sync queue proves the pattern, but cascading failures from a single invalid GeoJSON reveal sync's hardest unsolved problem.