Beyond the Cloud: The Local-First Software Revolution • Brooklyn Zelenka & Julian Wood
Distributed systems researcher Brooklyn Zelenka introduces local-first computing, a new paradigm where apps run on user devices, synchronizing via CRDTs like Automerge. This approach offers offline functionality, low latency, and enhanced privacy, ideal for collaborative "cozy web" applications and democratizing development by simplifying the tech stack.
For the last 30 years, software has largely been built on the same client-server model. This architecture requires a central server, creating dependencies on connectivity, introducing latency, and concentrating data and control. Distributed systems researcher Brooklyn Zelenka proposes a fundamental shift with local-first computing, an architecture where applications run primarily on the user’s device, challenging the necessity of a central server for many tasks.
A New Architectural Model
The core idea of local-first computing is to re-architect software so that a central, required server is no longer the single source of truth. Instead, every device—every replica of the data—is its own source of truth. This model leverages the significant computational power of modern devices, like smartphones, to handle most tasks locally.
This approach yields several key benefits:
- Reduced Latency: By performing computations locally instead of making a round trip to a data center (e.g.,
us-east-1), applications feel significantly faster and more responsive. - Offline Functionality: Users can continue working without an internet connection, such as on a train or plane. Changes are synchronized once a connection is re-established.
- Resilience and Longevity: Applications are not dependent on a company’s infrastructure. If a service provider shuts down an application (a common occurrence), the software continues to function locally for the user.
The Technology Behind Local-First
The magic that enables seamless collaboration and synchronization in a decentralized environment lies in specialized data structures.
- Conflict-Free Replicated Data Types (CRDTs): These are advanced data structures that allow data to be merged automatically without conflicts. Think of it like a Git repository that handles all branching and merging automatically, without requiring manual intervention. Projects like Automerge provide developers with a JSON-like API to manage data, abstracting away the complexity of the underlying CRDT.
- Sync Servers: While the model reduces reliance on central servers, it doesn’t eliminate them entirely. Instead of powerful, stateful application servers, local-first architectures use lightweight “sync servers.” These are essentially dumb relays; their only job is to receive encrypted blobs of data, associate them with a label, and forward them to other authorized clients. They have no knowledge of the data’s schema or content, making them highly scalable and interoperable.
Solving for Access Control and Security
In a world where every collaborator has a full copy of the data, traditional security models based on network boundaries break down. Local-first access control is solved with a two-pronged cryptographic approach:
- Read Access: All data is encrypted at rest. A user must possess the correct cryptographic key to decrypt and read the information. The sync server only ever sees encrypted bytes, so a breach of the server does not expose the underlying data.
- Write Access: Every change (mutation) to a document is digitally signed by the author. When a replica receives a change, it verifies the signature against a list of authorized members. If the signature is invalid or the author is not on the list, the change is simply discarded.
Use Cases: “Small World” vs. “Big World”
Local-first architecture is not a silver bullet for every application. It excels in what can be described as “small world” or “cozy web” scenarios.
- Ideal Use Cases: Collaborative applications for individuals, small groups, or even up to thousands of users. Examples include collaborative document editors (like a Google Docs clone), drawing applications, messaging apps, and shared shopping lists.
- Less Suitable Use Cases: “Big world” applications that require massive-scale indexing and discovery across millions of users, such as ingesting the entire Blue Sky or Twitter firehose. These scenarios still benefit from centralized services to build and serve indices.
The simplicity of the local-first stack also democratizes application development. With a lower barrier to entry, developers with primarily front-end skills can build and ship robust, collaborative applications. This fosters the creation of what Robin Sloan calls “home-cooked” apps, built for small, trusted communities rather than for massive, venture-backed scale.
The Future: Local-First Compute
The paradigm extends beyond data to computation. The Interplanetary Virtual Machine (IPVM) is a research project exploring local-first compute. Using WebAssembly (Wasm) as a portable binary format, computation can be moved to the data. A low-powered device could offload a heavy task (like rendering a 3D scene) to a more powerful machine on the network and receive the result back. If offline, the task can still run locally, albeit more slowly. This ensures that the application remains functional regardless of connectivity, while still being able to leverage external resources when available.