Each person keeps their own data on their own Mac and shares what they choose, end-to-end encrypted. Your code runs on their machines, and you host nothing.
Every read and write goes through the company that runs the app. It holds everything, and everything stops when it does.
Each ring is one person’s node, on their own machine. A line is a database two people share, carried by an encrypted cloud that cannot read it. People and connections come and go.
Every person has their own database, on their own machine. People share databases with each other: a family, a team, a club. Picture a social network where each person holds their own posts and decides who receives them.
Each person’s Mac stores their data and runs your code, so a thousand users are a thousand machines doing their own work. You have no backend to scale, because you have no backend.
A shared database is not behind someone’s API. Every member’s machine holds it, so your app works on it directly, with your own logic, in any language. A feed, a marketplace, a game, a ledger: if you can write it, it runs.
All of your code runs on your users’ machines. The cloud stores and passes along end-to-end encrypted bytes. It runs none of your logic, and you host nothing.
To let people use an app together, you usually build one place that holds all of them. You run that database, you write the sync, and you hold every user’s data in an account that you must protect.
The next app does all of it again. People end up with one copy of their life in each app, and own none of them. LastDB starts from the other end: one person, one database, on their own machine.
LastDB is one background service. Your app reads and writes it over a local Unix socket. Nothing in this step needs a server of yours.
A schema names its fields, its primary key, and any alternate keys. Each app keeps its own records. No app owns the database.
One person can use it with no account and no network. Encrypted cloud backup is optional. Nothing below this line is needed until two people want to use the app together.
Any language that can send HTTP over a Unix socket can use LastDB. Shown with curl.
An app sends three requests: it declares a schema, writes a record, and reads it back by key. All three are plain HTTP with a JSON body. This is the write.
curl -s --unix-socket ~/.lastdb/data/folddb.sock \
-X POST http://localhost/api/mutation \
-H "Content-Type: application/json" \
-d '{
"type": "mutation",
"schema": "notes/note",
"record": { "id": "n1", "tag": "work", "body": "Ship the page" },
"key_value": { "hash": "n1", "range": null },
"alternates": { "by_tag": { "hash": "work", "range": null } },
"mutation_type": "create",
"expected": { "type": "absent" }
}'You build and run the app on your own Mac, against your own data. What you ran is what everyone gets. There is nothing to deploy: a release is a signed entry in the App Registry that names the app, its schemas, and the commit to install.
Each person installs the app by name. It runs on their Mac, against their own LastDB and the databases they share. An update is a new entry that their LastDB checks before it installs. Publishing needs a paid Exemem subscription. Building and running locally does not, and the people who install your app pay nothing to use it.
lastdb app publish --manifest manifest.json
lastdb app install your-app
Records found by key. No read walks a whole schema, so a read stays fast as the data grows.
Encrypted cloud backup, and recovery onto a new Mac. No name or email address. The cloud cannot read it.
A person publishes a database and invites others. Their LastDB checks every change that comes back.
A signed list of apps. You publish to it, and each person installs by name. There is no server to deploy.
Two starter apps show how it is done: Brain for notes and decisions, and LastSecrets for credentials. Coming: LastSeek, semantic search beside the database. It is not in the App Registry yet.
You need Apple Silicon, Homebrew, and Bun. The installer checks for all three and stops if one is missing. Read the script first: install.sh.
curl -fsSL https://thelastdb.com/install.sh -o install.sh sh install.sh
The first run installs LastDB, prints the plan for the starter apps, and stops with RESULT: CONSENT NEEDED. That stop is expected.
sh install.sh --accept-install brain init
It ends with RESULT: PASS when the apps are current and healthy.
lastdb and lastdbd commands and starts the LastDB service.~/.local/share/lastdb-apps and links its commands into ~/.local/bin.launchctl bootout "gui/$(id -u)/com.edgevector.lastdb-app-registry" rm "$HOME/Library/LaunchAgents/com.edgevector.lastdb-app-registry.plist" rm -rf "$HOME/.local/share/lastdb-apps" "$HOME/.local/state/lastdb-app-registry" brew services stop lastdb brew uninstall lastdb
Your data stays in ~/.lastdb. Delete that folder only if you want to lose the data. This cannot be undone.
brew install edgevector/lastdb/lastdb brew services start lastdb lastdb status
Add apps later with lastdb app install.