HenkSuiteTL;DRLocal-first apps keep the canonical copy of your data on your device, work fully offline, and treat sync as a feature layered on top - often with CRDTs (conflict-free replicated data types). The model, popularized by Ink & Switch in a 2019 essay, is becoming the future of productivity because hardware got fast, cloud fatigue is real, and privacy finally became a consumer concern. Tools like HenkSuite, Obsidian, Anytype, and Logseq are the early wave.
Quick answer: what local-first apps actually are
A local-first app stores your data on your device as the source of truth. The network is optional - reading, writing, searching, and editing all happen without a server. If you want sync, the app layers it on top, usually using CRDTs so two devices can diverge and later merge without conflicts.
In practice, local-first apps open instantly, work on a plane, survive vendor outages, and don't hold your data hostage. They're the opposite of the SaaS default - and in 2026, they're quietly eating the productivity category.
Where the local-first idea came from
Ink & Switch and the 2019 essay
The phrase "local-first software" was coined in a 2019 essay by researchers at Ink & Switch, an independent computer science research lab. The essay argued that cloud-first SaaS had quietly traded away several good properties of older desktop apps - ownership, longevity, privacy, and reliability - in exchange for collaboration and convenience. The proposal: get both.
The essay treated local-first not as a nostalgic call for shrinkwrapped software, but as a research agenda. How do you keep data local and still collaborate in real time? How do you sync without a central server? How do you make software that outlives its vendor?
The seven ideals of local-first software
The Ink & Switch essay lists seven ideals. Any app that calls itself local-first should meet most of them:
- No spinners: the app responds instantly because it doesn't wait on a server.
- Your work is not trapped on one device: sync is supported, but optional.
- The network is optional: everything works offline.
- Seamless collaboration with colleagues: multiple devices can edit and merge.
- The Long Now: the data outlasts the app and the company.
- Security and privacy by default: encryption where it matters, and no unnecessary server access.
- You retain ultimate ownership and control: no one can lock you out or take your data away.
Seven years later, these ideals feel less like research principles and more like a consumer wish list.
Not a trend - a thesisLocal-first isn't a style or a vibe. It's a thesis about how software should be built in the 2020s: data on your device, network optional, sync via merge-friendly data structures, and no vendor-lock-in by default.
Why local-first is winning now
Hardware caught up
The cloud-first era made sense partly because phones and laptops were too weak to do serious work on their own. In 2026 a $1,000 laptop has an 8-core CPU, an NPU, 16GB+ RAM, and a 1TB SSD. That's more than enough to run a full SQLite database, search thousands of documents instantly, and host a local AI model. "Ship it to the cloud" is no longer the only way to make heavy features fast.
Cloud fatigue is real
A decade of SaaS taught users the downsides: subscription creep, vendor lock-in, slow UIs, price hikes, pivots, acquisitions, and outages. When Figma had its first serious outage, designers realized they couldn't do their job without someone else's servers. That moment repeats across every SaaS category.
Privacy became a consumer issue
GDPR, high-profile breaches, AI training scandals, and questions like "is my therapist's note-taking app training an LLM on me?" pushed privacy into mainstream awareness. Local-first is the simplest possible answer: if the data never leaves your device, the question goes away.
How local-first sync actually works
CRDTs: conflict-free replicated data types
CRDTs are data structures that can be edited independently on multiple devices and merged deterministically - no central server needed to resolve conflicts. Think of them as spreadsheet cells that know how to merge themselves. Automerge and Yjs are the two most-used CRDT libraries; both power serious local-first apps today.
The practical upshot: two people can edit the same document on a plane, and when both reconnect, the app merges their changes automatically, without losing either. That used to require complex server logic. CRDTs move it to the client.
Sync engines and relay servers
Most local-first apps still use some server - but only as a dumb relay. Devices connect to it, exchange encrypted change blobs, and disconnect. The server never reads your data; it just moves bytes between your devices. This is the opposite of SaaS, where the server owns your data and your device is a thin viewer.
End-to-end encrypted sync
Because relay servers never need to read your data, local-first apps can layer end-to-end encryption on top. Anytype, Apple iCloud (for some features), and emerging sync engines all do this. The server sees gibberish; only your devices see the plaintext. This collapses the privacy question into a much simpler one.
Local-first apps worth knowing
HenkSuite - local-first productivity suite
HenkSuite is a native desktop suite (Tauri 2, local SQLite) that applies the local-first thesis to the full productivity stack. Projects, tasks, notes, calendar, mail, spreadsheets, time tracking, habits, goals, finance - 21 native modules, one SQLite file, sub-millisecond reads, fully offline, no cloud dependency. One-time license, no subscription, data stays on your device.
It's one of the few local-first apps that replaces a whole stack rather than a single category. That matters because the subscription tax on productivity isn't one app - it's five.
Obsidian, Anytype, Logseq, Linear's offline mode
Obsidian - local Markdown notes, plugin ecosystem, the most honest local-first notes app. Anytype - local-first, E2EE, open-source, Notion-shaped. Logseq - local outliner with a graph, favored by academics. Linear - a cloud project manager that adopted a local-first sync engine internally and is the reason it feels fast. Expect more SaaS apps to quietly re-architect toward local-first without calling it that.
What happens next
Three things are about to accelerate:
- Cross-app local-first storage: shared, owner-controlled data layers (think a "personal database") that multiple apps can read and write, breaking today's one-app-one-silo model.
- Local AI on local data: with NPUs on laptops and small local LLMs, you can ask intelligent questions about your own notes without shipping them anywhere.
- Mainstream consumer adoption: today local-first is a power-user movement. Over the next two years, mainstream users will follow - not because they read the essay, but because local-first apps are faster, cheaper, and quieter than the alternatives.
The quiet inevitabilityCloud-first won the 2010s because the network was the expensive, capable part of the stack. That's no longer true. The most expensive, capable computer in your life is in your backpack. Local-first is just software catching up to that fact.
FAQ: local-first apps
What is the difference between local-first and offline-first?
Offline-first means the app keeps working when the network drops. Local-first is a stronger claim: your device holds the canonical copy of the data, you own it, and the network is optional even when it's available. All local-first apps are offline-first, but not all offline-first apps are local-first.
Can local-first apps work for teams?
Yes. CRDTs and encrypted relay servers make multi-device, even multi-user collaboration possible without a central cloud database. Linear, Muse, Figma-like prototypes, and emerging local-first team apps prove it. The tradeoff: real-time multiplayer editing on very large teams still favors cloud-first. For small teams, local-first is already more than enough.
Where can I learn more about local-first software?
Start with the Ink & Switch essay on local-first software, then look at the Automerge and Yjs CRDT libraries. For a working example you can install today, try a local-first productivity app like HenkSuite - the easiest way to feel the difference is to use one.
The bottom line
Local-first apps aren't a nostalgia play or a privacy niche. They're the natural answer to the question software has been dodging for fifteen years: whose computer is running your life? In 2026, it's finally respectable to answer "mine."
If you want to feel the future now, take HenkSuite for a spin. One native app, one SQLite file, no cloud required - a working example of the local-first thesis for the full productivity stack.
About the author
Emilia is the founder of HenkSuite. She builds productivity tools because the internet has 47 of them and none of them feel fast, private, or finished.