There is a conference happening right now where Martin Kleppmann is talking about CRDTs and Adam Wiggins is talking about the future of software. Neither of them works at a cloud company. Neither of them is building for the server. They are building software that runs on your device first, syncs when it can, and doesn't fall apart when it can't. This is the local-first conference, and the fact that it exists at all tells you something about where we are in the arc of computing.
For fifteen years, from roughly 2010 to 2025, the assumption was that software lives on servers. Your data, your logic, your identity - all of it rented from someone else's machine. This was presented as inevitability, not as a choice. It was the cloud era, and the cloud era's central premise was that you don't need to own anything. You subscribe. Your files are in someone else's database. Your writing is in someone else's editor. Your photos are in someone else's album.
The local-first movement looks at this and says: we tried that, and the tradeoffs are worse than advertised. An internet connection should not be a prerequisite for using the tools you depend on. A company going bankrupt should not delete your work. A terms of service update should not change what you can and cannot do with your own data.
This is not a technical argument dressed up as a political one. It is a technical argument and a political one, and the tension between them is what makes the movement interesting. The sync engine crowd is optimizing for latency and offline resilience. The manifesto crowd is optimizing for sovereignty and independence. They are at the same conference, and they are talking past each other, and that is fine. The productive friction between these two tracks is where the interesting work happens.
Games have been local-first since the SNES. They never stopped. A game cartridge contains both the program and the save state. It does not phone home. It does not require an account. When the network goes down, the game still works. The cloud detour - the idea that everything should live on servers - was always an anomaly in the history of computing. Games just refused to take the detour, and nobody noticed because games are not serious software. But the patterns games have used for decades - deterministic state, local persistence, sync as an afterthought - are exactly the patterns local-first is rediscovering now.
The timing is not accidental. Bonsai 27B runs on a phone. Useful models no longer require a datacenter. When the intelligence layer of your application can run locally, the argument for centralizing everything on servers collapses. Local-first stops being a philosophical stance and becomes the default architecture again. The cloud was a hardware workaround for an era when phones couldn't run useful models. That era is ending.
But the movement has real problems. The tools are built by developers for developers. Setting up actual local-first software requires git, a terminal, and a willingness to debug sync conflicts that nobody has documented because the state space is too large. The consumer gap is real. The people who would benefit most from data sovereignty cannot open the box. If local-first stays a developer niche, it is a tool preference, not a movement.
The economics do not add up yet. The conference could not afford to fly speakers in. One of them is crowdfunding their travel. Local-first solves a real problem, but the people building it operate on a shoestring while the cloud model has deep pockets and a salesforce. Something has to bridge that gap. Open source had Red Hat. Linux had IBM. Local-first needs its patron, and that patron has not arrived yet.
There is a debugging tax nobody talks about. When your app runs on a server, you SSH in and look at the logs. When your app runs on a user's device, you cannot SSH in. Reproducing sync bugs is a nightmare. We need a new debugging paradigm for distributed state, and we do not have it yet. The cloud's centralization was not just about control - it was also about observability. Local-first gives users their sovereignty back, but it takes away the developer's ability to see what is happening. That is a real cost.
Collaboration is the hardest problem. The cloud won because Google Docs made sharing zero-friction. You send a link, someone clicks it, and you are both editing the same document. No setup, no sync, no version control. Local-first collaboration starts with a conversation about which tool to use, how to connect, and what happens when two people edit the same thing offline. The social friction of setup is the cloud's killer feature, and local-first has not solved for it yet.
The co-optation question looms. Local-first faces the same fate as every counter-cultural movement in tech. Open source got bought by Microsoft. The indie web became a newsletter platform. The conference having non-local-first sponsors is not hypocrisy - it is the shape of a movement entering a new phase. The question is what survives professionalization. When a venture-backed company starts marketing "local-first" as a feature of their cloud product, will the movement still mean something? Or will it become another label that got absorbed and neutralized?
Maybe the winning condition is mundane. You open an app on a plane and it just works. No spinner. No "you are offline" banner. No data loss when the wifi cuts out. The cloud becomes a sync layer instead of the entire architecture. You do not think about where your data lives because it lives everywhere - on your device, on your partner's device, and on a server you never have to care about until something breaks. Reliability becomes invisible again, which is the only kind of reliability that matters.
The local-first conference is happening while most developers are still building cloud-dependent apps. The people at this conference are not fringe. Kleppmann wrote the book on streaming data. Wiggins co-created Heroku. Their presence signals that something serious is forming. Not a revolution, not a rejection of the cloud, but a quiet recognition that the bet was too one-sided. Software should work without permission. Data should survive corporate failures. Users should own what they create. These are not radical ideas. They are the default assumptions of computing before 2010, and they are coming back.