The Ultimate Guide to Local-First Software

Local-first software stores data on your device and syncs when needed. This guide explains what it is, why it matters, and the best local-first tools available.

Mark Rachapoom

March 20, 2026·7 min read

Local-first software is a design philosophy where your data lives on your device by default, and synchronization with other devices or servers happens as a secondary operation. If you've used Obsidian, Figma's offline mode, or DenchClaw, you've experienced local-first software.

This guide explains what local-first means, why it matters for users and businesses, and how to evaluate local-first tools.

What Is Local-First Software?#

The term "local-first" was formally articulated by Ink & Switch in their 2019 essay "Local-First Software: You Own Your Data, in Spite of the Cloud." The core principles:

No spinners: The software responds instantly because data is local
Your work is not trapped on one device: Sync makes data available across your devices
The network is optional: Core functionality works without internet
Collaborators can see your changes: Sync handles conflicts without a central server
The Long Now: Software should work in 10 years without the vendor
Security and privacy by default: Encryption, private by default
You retain ultimate ownership and control: Data in formats you can read

These principles contrast with cloud software, where: responses include network latency, data is trapped in the vendor's database, network is required, central servers resolve conflicts, software may stop working if the vendor shuts down, privacy is policy-based, and you control access only via the vendor's interface.

Why Local-First Matters#

Performance#

The physics of network communication create an irreducible latency floor. San Francisco to Northern Virginia: minimum 50ms round-trip. With API overhead: 200-500ms for typical operations.

Local storage has no network latency. Query time is bounded by disk I/O and computation — typically 1-20ms for well-optimized applications. The difference is not small. 200ms vs. 5ms is the difference between a tool that feels slow and a tool that feels instant.

Ownership#

When data is local, you own it in a concrete sense:

You can back it up with any tool
You can open it with alternative clients
You can migrate to different software without the vendor's cooperation
You don't need the vendor to give you access to your own data

Cloud software offers "ownership" that's really access at the vendor's pleasure. Local-first offers actual ownership.

Privacy#

Local data doesn't transit anyone else's infrastructure. The attack surface is your device, not a multi-tenant database shared with millions of other users. For sensitive personal or business data, this is a meaningfully better security posture.

Reliability#

Local software works when the internet is down, when the vendor has an outage, when you're on a slow connection. Cloud software doesn't.

Local-First Tools in 2026#

Note-Taking and Knowledge Management#

Obsidian (proprietary but local-first): Markdown-based notes stored in plain files on your filesystem. No cloud storage required. Sync optional. The gold standard for personal knowledge management. Enormous plugin ecosystem.

Logseq (AGPL): Outliner-based knowledge graph. Local Markdown files. Strong community.

Capacitor (MIT): Plain-text journaling with local storage. Simpler than Obsidian.

CRM and Business#

DenchClaw (MIT): AI-native CRM. DuckDB local database, OpenClaw agent runtime. Natural language interface. The most advanced local-first CRM available. npx denchclaw

Monica (AGPL): Personal CRM for managing relationships. Simple, focused, self-hostable.

Code and Development#

VS Code / Cursor: Code editors are inherently local-first. Files on disk, Git for sync.

Zed (GPL): Local-first code editor with optional collaborative features.

Email#

Mimestream (proprietary): Local-first Gmail client for macOS. Much faster than web Gmail.

Himalaya (MIT): Terminal-based email client. Local IMAP sync.

Tasks and Todos#

Obsidian Tasks (MIT plugin): Task management in Markdown files.

Things 3 (proprietary): Local-first task manager for macOS/iOS. iCloud sync.

OmniFocus (proprietary): Advanced local-first task management.

Design#

Figma (proprietary): Primarily cloud-first, but has good offline mode and local caching.

Sketch (proprietary): Mac-only design tool, local files with optional cloud sync.

The Sync Problem#

The hardest part of local-first software is multi-user sync. When multiple people edit the same document simultaneously on different devices, you need a way to merge those edits without losing data.

Approaches to Sync#

Last-writer-wins: Simple but lossy. The last change overwrites previous changes.

Operational transformation (OT): Used by Google Docs. Complex algorithm that transforms operations to handle concurrent edits. Requires a central server as the coordinator.

CRDTs (Conflict-free Replicated Data Types): Mathematical data structures that can be merged deterministically without a central coordinator. Multiple implementations available:

Yjs (MIT): The most popular JavaScript CRDT library
Automerge (MIT): Alternative CRDT implementation
Electric SQL (Apache 2.0): Postgres-based local-first sync

DenchClaw's team sync is built on CRDT principles. Each user has a complete local copy; changes sync when connected.

What Good Sync Looks Like#

Changes appear immediately on the local device (no waiting for server confirmation)
Changes propagate to other devices in the background
Conflicts are resolved automatically (or with clear UI for irresolvable conflicts)
The sync server is a relay, not a single point of failure
If the sync server is unavailable, local changes are preserved and sync when it returns

Evaluating Local-First Tools#

Step 1: Check Data Format#

Where is your data actually stored? Local-first tools store data:

As plain files on your filesystem (Obsidian: Markdown, DenchClaw: DuckDB)
In a local database (DenchClaw: ~/.openclaw-dench/workspace/workspace.duckdb)
In a local cache with remote backup (iCloud Drive apps)

Avoid tools that call "local-first" but store primary data in the cloud with a local cache.

Step 2: Test Offline Functionality#

Open the tool with WiFi disabled. Can you:

Create new content?
Edit existing content?
Search?
Access your data?

A true local-first tool answers yes to all of these.

Step 3: Verify Export and Portability#

Can you export your data independently of the vendor? Test:

Export formats available (open formats like CSV, Markdown, JSON are good; proprietary binary formats require caution)
Export process (one-click vs. request/wait)
Completeness (does the export include everything, or are some things left behind?)

Step 4: Assess Sync Model#

If you need multi-device or multi-user sync:

How does sync work? (What protocol, what conflict resolution)
Is sync optional? (Can you use the tool without sync if you don't need it)
What happens if the sync server is unavailable? (Data should be preserved locally)
Can you use third-party sync (your own S3 bucket, iCloud, Dropbox)?

Local-First for Teams#

Local-first software for teams is harder than for individuals because of the sync problem. The current state:

Obsidian with iCloud or Obsidian Sync for teams: Works reasonably well for knowledge bases. Conflict resolution is good; UI for conflicts could be better.

DenchClaw team sync: In development. The CRDT-based approach will handle team CRM well.

VS Code + Git: The gold standard for collaborative code. Each person has a local copy; Git handles the sync.

The pattern that works: each person has full local copies, sync happens through a relay service or peer-to-peer mechanism, conflicts are resolved via CRDTs or explicit merge.