Why Wish

Most cloud apps don't need a cloud. They need three things: a way for users to identify themselves, a way for users' devices to talk to each other, and a way to store and share data. Today, we rent these from servers. Wish is built on the bet that you don't have to.

The thesis

A modern social network, file sync service, group chat, or collaboration tool is, at its core, users producing data and sharing some of it with each other. The server in the middle is an accident of how we learned to build software, not a requirement of the problem. Strip it out and replace it with cryptographic identity, peer-to-peer transport, and signed storage, and you get the same apps with very different properties:

• The user's data lives on the user's devices.
• There is no backend to deploy, scale, or operate.
• Federation, multi-device sync, and offline support fall out for free.
• The vendor surface — what you have to trust, what can be subpoenaed, what locks you in — shrinks dramatically.

Wish is a working demonstration that this is buildable, today, in production-quality code.

What's actually built

The Wish stack runs end-to-end:

Layer	What's there
Apps	Reason · Hailer · Journal · wsh · git-wish
Data layers	Document Store · file sync · (your choice)
SDK	wish-sdk — daemon, peers, RPC, sync
wish-core	identity · transport · encryption · contacts

wish-core is the foundation: Ed25519 identities, ICE/uTP transport with NAT hole-punching, encrypted peer connections, the contact model. It's a C binary that runs on every user's device. It's solved infrastructure.

wish-sdk is the Node.js entry point for app authors. Your app connects to a local wish-core, requests an identity grant from the Wish Dashboard, and starts talking to peers.

Document Store is one example of a data layer built on this foundation — a content-addressed document database with per-field write rules and per-document share policies, syncing peer-to-peer. It's the layer Reason and Hailer use. It is not the only possible data layer.

What's still up to you

Wish provides the boring solved layers. What it deliberately leaves open is the shape of your data and the patterns of your app:

• Document-shaped data — Document Store, available today.
• CRDT-style collaborative editing — drop in Automerge or Yjs on top of wish-core; the transport and identity are right there.
• Streaming / large-file — wish-core's frames carry whatever you want. A Hypercore-style append-only feed is a perfectly reasonable thing to build.
• Anything we haven't thought of — a key-value store, a graph database, a federated event log. The stack underneath doesn't care.

The thesis isn't "use Document Store." The thesis is "the foundation that makes all of these viable, without a server in the middle, exists and works."

Who this is for

You'll get the most from Wish if you're building apps where any of these are features:

• The user owns their data — not a copy of it, the actual data.
• The app keeps working offline; sync is the recovery path, not the data path.
• Multi-device for one user "just works."
• You don't want to operate a backend, hold user data, or build an identity system.
• You're willing to ship an app the user installs rather than a URL they visit.

If your business model depends on holding user data, or your app is a single global feed, Wish is the wrong tool. For everything else worth questioning, it's at least worth a look.

Start here

• Download Wish — the tray app for your platform, includes wish-core and Dashboard.
• SDK quick start — build your first app.
• Document Store — the data layer that's ready to use.
• Source — the whole stack lives in a private repository while it matures; access is handed out personally. Get in touch.

Further reading

• Things you can't easily do today — a short list of things most of us have learned to live with. They aren't laws of physics.
• Isn't this just a walled garden? — the most common pushback, addressed. Discovery and public access work; what changes is that fake accounts stop scaling.
• Security from simplicity — most breaches are predictable consequences of having a lot of surface to defend. What disappears when there is none, and what's left.
• Permissionless innovation — the early web let anyone build on top of anyone's content, and we lost that. What changes when data lives on the user's device.
• Attestation chains — how trust works without certificate authorities. A pharmacy verifies a prescription in a system with no central healthcare database.