local-first

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.

Local First & Social Software in the Era of LLMs

by zhanna-sharipova

Owning your data isn't enough — local-first must extend to owning your communication channels, and the same infrastructure that protects human social connections will become the foundation for a trustworthy multi-agent future.

Safe in the Keyhive: Local-First Access Control with E2EE and Capabilities

by brooklyn-zelenka

Auth must travel with data in local-first — Keyhive solves this with capability-based certificate chains and a membership CRDT, making the sync server unable to read your data while keeping the UX as boring as a Google Docs share button.

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.

Why Local First Matters to Businesses

by adam-fish

Local-first technology only matters if it translates into business outcomes — reliability, speed, revenue. The biggest trap is optimizing for developer fascination instead of real-world impact.

rstore

by guillaume-chau

A reactive normalized cache for Vue and Nuxt that unifies query caching, cache normalization, optimistic mutations, form handling, and real-time subscriptions behind a pluggable data source architecture — the missing data layer between Pinia and full sync engines.

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?

I Built a Context7 Local-First Alternative With Claude Code

by moshe-simantov

Documentation indexing for AI agents belongs on the local machine: pre-built SQLite databases eliminate rate limits, cut query latency to sub-10ms, and keep proprietary code queries completely private.

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.

Local-First in Production — FOSDEM 2026 Recap

by m-palanikannan

Shipping CRDTs to real users teaches lessons no demo can: save the binary as source of truth, never overwrite—always merge, and build fallbacks for when WebSockets inevitably die.

Local-First Software: Pragmatism vs Idealism

by adam-wiggins

Movements like local-first succeed when idealists define the vision and pragmatists build the infrastructure—neither alone crosses the finish line.

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

Alkalye

by carl-assmann

A local-first markdown editor PWA with E2E encryption, collaborative editing, and presentation mode.

Home-cooked Software and Barefoot Programmers

by maggie-appleton

Language models will enable a new class of 'barefoot developers'—technically savvy non-programmers who build small-scale, personal software for their communities, and local-first should position itself as the default infrastructure before cloud platforms lock them in.

Implementing Fractional Indexing

by david-greenspan

A technique for maintaining ordered sequences in collaborative systems using string-based keys that allow arbitrary insertions without renumbering.

Local First: the secret master plan

by peter-van-hardenberg

Ink & Switch's three-part vision: local-first software enables universal version control, which enables malleable software — and the philosophical endgame is turning people from app buyers into tool users.

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.

The Ultimate Mind Map Builder for Obsidian

by zsolt-viczian

Zsolt Viczián demonstrates his new Mind Map Builder script for Obsidian Excalidraw, enabling rapid visual thinking with keyboard navigation, markdown interoperability, and flexible layout controls.

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.

How I use Obsidian

by steph-ango

Steph Ango's personal note-taking system emphasizes file-based storage, minimal folder hierarchy, and emergent organization through linking rather than rigid structure.

Why Local-First Apps Haven't Become Popular

by marco-bambini

Explains why local-first apps remain niche despite their advantages—syncing data across distributed devices without losing information is genuinely hard.

Malleable Software

by ink-and-switch

A research agenda for malleable software—tools that users can adapt to their needs without relying on developers, restoring agency in an era of locked-down applications.

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.

Local-First Software: You Own Your Data, in Spite of the Cloud

by martin-kleppmann, adam-wiggins, peter-van-hardenberg, mark-mcgranaghan

A foundational essay proposing that data ownership and real-time collaboration are not mutually exclusive, introducing CRDTs as the enabling technology for local-first software.

What is Local-first Web Development?

by alexander-opalic

An introduction to local-first web development, a paradigm shift that prioritizes storing data on users' devices first, enabling offline functionality, instant access, and greater user control over their data.

Basic Likes Feature with LiveStore

by bohdan-ptyts

LiveStore's event sourcing model makes implementing persistent, synced features trivial—define an event, a materializer, and a reactive query, and the framework handles offline support and cross-device sync automatically.

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.

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.

File Over App

by steph-ango

Digital artifacts that last require files you control in open formats—apps are temporary, but plain text endures.