The architecture and trends of local-first sync engines

The Data Ownership Paradigm

Local-first software moves the primary data copy to the client device. This architecture treats the client as a node in a distributed system with its own database. Users work with local data in IndexedDB or the Origin Private File System. Sync happens in the background. This allows users to work effectively even when the internet connection fails. Modern browser storage capacities allow users to cache hundreds of megabytes or even gigabytes of data.

Data stays local.

The shift to local-first differs from the progressive web app model. Progressive web apps focus on installing website shortcuts on home screens. Offline-first applications imply that offline mode is more important than online mode. Local-first focuses on a data architecture where the client holds the primary copy. This approach avoids the latency of every user interaction being a round-trip to a server. You know the basics of client-server models, so focus on the data layer.

The seven ideals of local-first are speed, multi-device support, offline capability, collaboration, longevity, privacy, and user ownership. Legacy storage like localStorage caps at 5 to 10 megabytes and only stores strings. Modern developers use IndexedDB to store much larger datasets. The Origin Private File System provides near-native file I/O for web apps. This API allows for fast, synchronous reads and writes in Web Workers. Sync happens in the background.

Algorithms and Conflict Resolution

Developers choose between Operational Transform (OT) and Conflict-free Replicated Data Types (CRDTs) for multiplayer functionality. OT requires a centralized server to maintain a linear revision history. This approach preserves user intent in rich text editing. When Alice inserts a character at position 3 and Bob deletes a character at position 1, OT transforms Bob’s delete so Alice’s insert position adjusts correctly. CRDTs allow for decentralized, peer-to-peer communication without a central authority.

CRDTs carry unique IDs and tombstones for every single element. Because CRDTs carry unique IDs and tombstones for every single element, a 50,000-word document might require up to 3.2 MB of additional metadata for the system to handle synchronization effectively. In a mid-size workspace with 10,000 nodes, each containing 200 characters of text, CRDT storage can reach 66 MB while OT storage stays around 2 MB. AI agents generate operations 25-100x faster than humans. This speed stresses both algorithms.

Is there a perfect algorithm for all data types?

State-based CRDTs share complete data between replicas. Operation-based CRDTs broadcast the actual operations that modify the data. One common CRDT type is the G-Counter, which is a grow-only counter. PN-Counters extend this to support both increments and decrements. Sequence CRDTs, like the YATA algorithm used by Yjs, manage ordered data like text documents. Automerge uses a Rust-based implementation to improve performance for larger documents. OT remains common in large-scale text editors where preserving exact user intent is critical.

Sync Engine Implementation

Replicache functions as a client-side library. It uses mutators to update state. It handles initial data downloads and manages the rebase process. Replicache uses a push, pull, and poke mechanism to coordinate with the backend. Mutations are stored locally and replayed when connectivity returns.

ElectricSQL provides read-path synchronization. It streams data from PostgreSQL using logical replication but does not handle writes through the engine. PowerSync provides bidirectional sync and maintains a full SQLite database on the client. PowerSync supports multiple backends including MongoDB and MySQL. This makes it a strong choice for cross-platform apps.

Electric SQL uses long polling as a sync push mechanism. This technique is slow and brittle. Livestore requires that one user corresponds to one SQLite instance. This limitation makes it a poor fit for sharing data between users.

Zero integrates with Drizzle and maintains a small client footprint.

Sync is automatic.