Less server.More software.
For twenty years we have built apps as windows onto a database somewhere else. It made sense when phones were slow and disks were small. It does not make sense now, and the people who pay for it are the ones holding the device.
The distance is the problem
Every tap in a modern app travels to a data centre and back before anything is allowed to change on screen. We have become very good at disguising this: optimistic updates, skeleton screens, retry queues, caches with clever invalidation. But the distance is still there, and every disguise is code someone has to write, test and debug at two in the morning.
We do not think the answer is a faster network or a closer edge. The answer is to stop making the network part of the interaction.
Every disguise for latency is code someone has to debug at two in the morning.
Put the database where the user is
Devices now ship with fast storage and more memory than the servers we started our careers on. A real database fits comfortably on all of them. When reads and writes happen locally, the interface is instant by default, and offline is no longer a feature you add later; it is simply how the app works.
The server does not disappear. It becomes what it should have been all along: the place where copies meet, where rules are enforced, and where backups live.
Merge, don’t overwrite
If everyone has a copy, everyone can edit at the same time. That is a feature, not a risk, as long as edits merge instead of replacing each other. We use well-understood techniques for this, CRDTs where they help and plain last-writer-wins where they don’t, and we document exactly which one applies to every column.
Concurrent edits are a feature, not a risk.
Open, all the way down
A backend is a long-term relationship. You should be able to read every line of it, run it on your own hardware and leave without asking anyone’s permission. Kilnbase is Apache-2.0 from the client to the sync server, and it will stay that way. If we ever offer hosting, it will be the same code, and the reason to pay us will be that we run it well.
Build in public, including the bad weeks
We publish a build log every Friday. It includes the releases, but also the rewrites, the benchmarks we lose and the decisions we reverse. The roadmap is public, the RFCs are public, and the people who show up early get a real say in what we build.
This is slower than shipping in silence. We think it produces better software, and it lets you decide whether to trust us with your data before you hand it over.
What we are asking of you
Try it when your invite arrives. Break it. Tell us where it hurts, in an issue or in Discord. If one of these principles is wrong, argue with it in public; this document has a version number for a reason.
The short version
- Less Round tripsMore Local reads
- Less SpinnersMore Instant
- Less Glue codeMore Product
- Less Lock-inMore Open source
- Less YAMLMore TypeScript
- Less Cold startsMore Always on
- Less InvalidationMore Sync
- Less Online onlyMore Offline first
- Less RetriesMore Merges
- Less Rented dataMore Owned data
- Less PollingMore Streams
- Less DashboardsMore Files
- Less CeremonyMore Shipping
- Less OverwritesMore CRDTs
- Less HypeMore Benchmarks
- Less VendorsMore Contributors