Local-First Software, Explained: Why Your Apps Should Work Without the Cloud

Most of the software you use every day does not really run on your computer. Your notes live on someone else's server, your photos sit in a data center across the country, and if the company behind the app shuts down or raises its prices, your work goes with it. Local-first software flips that arrangement: your data lives on your device first, and the cloud becomes an optional helper rather than the landlord.

The term comes from a 2019 essay by the research group Ink and Switch, titled "Local-first software: you own your data, in spite of the cloud." The essay argued that the industry had swung too far toward cloud-everything, trading away speed, privacy, and longevity for the convenience of centralized servers. Seven years later, the idea has grown from a research provocation into a genuine movement, with a dedicated conference in Berlin and mainstream apps quietly adopting its principles.

Your data, on your device, first

Local-first has a simple definition: the primary copy of your data lives on your device, the app works fully without an internet connection, and synchronization across devices is a feature layered on top, not the foundation everything depends on.

Compare that with the default cloud model. In a typical cloud app, your device is basically a window into a database that lives somewhere else. Every keystroke travels to a server and back. Lose your connection and the app degrades or dies. The company can read your data, mine it for advertising, hold it hostage behind a price increase, or delete it when the product is sunset.

In a local-first app, the flow reverses. You type, and the words land on your own disk instantly. If you choose to sync, encrypted copies move between your devices, sometimes through the company's servers, sometimes through storage you control yourself. The app never needs permission from a distant server to open your own files.

This is not the same as simply working offline. Plenty of cloud apps have an "offline mode" that caches a little data as a courtesy. Local-first means the local copy is the real one. The cloud copy, if it exists at all, is the backup.

Why ownership beats renting

The case for local-first rests on three promises: ownership, offline access, and longevity.

Ownership is about control. When your notes are plain Markdown files in a folder you can see, no company can lock you out of them, change the file format, or train an AI model on them without your knowledge. You can open them with any text editor, back them up however you like, and move to a competing app without an export nightmare. Your data is an asset you hold, not a hostage you visit.

Offline access is about reliability. Planes, subways, rural cabins, and conference Wi-Fi all make the same point: the internet is not as dependable as software assumes. A local-first app opens instantly and saves instantly because it never waits on a network round trip. That speed is not just a nice feeling. It changes how an app feels to use all day, every day.

Longevity is the quiet one, and maybe the most important. Cloud apps die. Companies get acquired, pivot, or simply decide your tier of user is no longer profitable. When a cloud app dies, your data often dies with it. Local-first apps degrade gracefully: even if every server involved disappears tomorrow, your files are still on your disk, still readable, still yours. Formats like Markdown and plain text will be readable decades from now, long after any particular app is gone.

The cloud is a great backup drive and a terrible landlord. Local-first software keeps the convenience while handing you back the keys.

The sync trick: making collaboration work without a center

The hardest problem local-first had to solve was this: if there is no central server holding the one true copy, what happens when two people edit the same document on two devices?

The answer is a family of data structures called CRDTs, conflict-free replicated data types. A CRDT is a way of structuring data so that edits made independently on different devices can always be merged automatically, with no conflicts and no data loss. Both editors' changes survive. Nobody's work gets overwritten because they happened to sync second.

CRDTs are the quiet engine behind much of the movement. The open-source Automerge library, which grew out of Ink and Switch's research, gives developers a ready-made toolkit for building collaborative local-first apps. And the idea has gone mainstream: Notion, the archetypal cloud workspace, added CRDT-based offline caching in its version 2.53 update in August 2025, a sign that even the cloud giants now accept that users expect their apps to work without a connection.

CRDTs are not magic. They guarantee that data merges without loss, but they cannot resolve meaning conflicts: if two people rewrite the same paragraph in opposite directions, a human still has to decide. They also add complexity around storage and security that developers are still learning to manage. But they solved the core technical blocker, and the ecosystem of libraries and frameworks around them keeps maturing.

Local-first apps you can use today

You do not need to wait for the future to try this. Several apps you may already know are local-first, or close to it.

Obsidian is the flagship example. Your notes are plain Markdown files in a folder on your device. The core app is free, with no account required, and a community has built more than 2,000 plugins around it. Syncing across devices is entirely optional: the official Obsidian Sync service costs about $4 a month billed annually with end-to-end encryption, or you can sync the same folder yourself with iCloud, Dropbox, or Git for free.

Joplin takes a similar path and goes further on openness: it is fully open source, stores notes locally as Markdown, encrypts them end to end, and lets you choose any sync target or none at all. Logseq, another open-source option, keeps every page as a plain file you can version with Git. AppFlowy offers a Notion-style workspace with databases and boards, but keeps the data local first.

The pattern is spreading beyond note-taking. Linear, the project management tool, caches your data locally so the interface responds instantly even on bad connections. Apple Notes stores notes on your device first and syncs through iCloud. Figma's multiplayer editing grew out of related techniques for merging simultaneous edits. Each of these made the same discovery: users can feel the difference when the app does not have to ask a server for permission to show them their own work.

The movement still has growing up to do. True local-first collaboration at the scale of Google Docs remains hard. But the direction is clear. After a decade of moving everything into the cloud, software is learning that the device in your hand is a perfectly good place to keep your life.

References

Ink and Switch, local-first software essay. Obsidian pricing and plugin ecosystem coverage, 2026. Notion 2.53 CRDT offline caching coverage. Local-First Conference 2026, Berlin coverage. CRDT practical guide coverage.