dwrldOS
sovereign application platform · designed, built and operated by one person

One server. One front door.
Every project as one system.

dwrld is a capability-gated application platform and workstation. It boots its own OS layer in your browser and serves a whole catalog from a tiered content-addressed store — identity, on-demand services, and GPU offload, all behind one front door. Held surfaces sit behind a passphrase and object-and-relation capability grants; the wallet is not what opens them yet.

The server, live

Every node is a real surface, and every node that can be measured is — a live round trip, refreshed every 30 seconds. The hollow ones are held behind a capability: counted, never named, and deliberately never probed, because a latency is itself a signal. Drag to turn it.

drag to turn · scroll to zoom · unlabelled nodes are held and cannot be inspected
public account held operator

Open right now — no key, no wallet, no account

Seven further surfaces are held behind a capability — the vault, the council, the workstation, the machine room. They are not linked here on purpose: a door you can see is honest, a door you click into a password is not.

Two products, one built on the other

dwrld infrastructure

The operator's product: turn machines, apps, storage and identities into one capability-governed environment. Deploy an app as a signed manifest; serve hundreds of dormant apps on demand; recover a dead app from cold backup and make it live.

dwrldOS workstation

The user's product: enter with a wallet, get a scoped account + vault + the apps you're granted, and use every project as one coherent workstation — boot screen, orb menu, live console, 2D map (3D later).

Live projects — clickable

elev8
3D web app, recovered from a 400 GB cold backup, rebuilt cross-arch, served on demand.
Perspective
Two AI agents in structured debate — communication-first multi-agent research.
directory
The live network directory surface.
verify — needs an account
Image verification in production. A sign-in wall is the first and only thing a visitor sees, so it is not listed as open.
Council
Multi-agent research: agents with real doctrines deliberate on a home RTX 4060, exchange messages, and return one synthesis. Convened from a capability-gated page; no model runs on this server.
the wallet workstation
Wallet = account + vault + granted apps. The identity half is live — a key your browser holds, the same one on all three sites. The wallet does not grant apps yet.

Under the hood

The stack

Identity control plane (Ed25519 capability grants) · Zanzibar-style authz · content-addressed tiered store (RAM → SSD → 1 TB cold) · on-demand socket-activated services · reverse-tunnel GPU offload · one nginx front door. Backups, monitoring, one-mutation rollback — run like production.

The law

The protocol is dumb mail; the server is the gated dispersion centre. Capability lives in the server, never the transport — so authority is one auditable layer, revocation is a single epoch bump, and the transport stays reusable.

Not built yet — intended

Employer wallets
Hand a company a wallet — they log in to a scoped account with their own apps, vault, and a usage trail. The resume is a wallet.
Per-wallet vault
~5 GB of capability-scoped storage per account — a real, private data workspace, not a demo.
Protocol-native client
A merged wwc + prtcl client: secure control + fast custom-format data, so the browser talks straight to the server after one bootstrap hop.
3D hallway
Walk between apps as rooms in the game engine; flip 2D ↔ 3D. The workstation as a place.
Council, live
Multi-agent research runnable from your wallet, dispatched to home GPU nodes.

What I'm learning right now

Sharpening the fundamentals

Unaided data structures & algorithms — a daily no-AI hour, so I can defend the reasoning as well as the systems. The goal isn't to lean on agents; it's to out-think the problem first, then direct the fleet.

Going deeper on systems

Distributed systems, capability security, and the parts of my own stack I want to defend line-by-line — the netcode tick loop and the capability-grant verify path. I built these with agents; I'm learning to own every decision in them.