The 0x network: players carry the game.
On 0x, most of what a player downloads comes from other players, not from our servers. Game files, live world data and multiplayer updates travel peer to peer. Every byte is checked against a hash or a signature, so a peer can be slow but can never change what you get. When peers can't help, the origin server always can.
Overview
0x is a game platform: accounts, a store catalog, a launcher, multiplayer services and hosting for web games. Under it sits one idea: the server says what is right, the players move the bytes. The server publishes hashes, manifests and signatures. Players fetch the actual data from each other, check it, keep it, and pass it on.
The pieces
API and push gateways
Accounts, catalog, entitlements, lobbies, leaderboards, cloud saves. Push over WebSockets, with missed events replayed on reconnect.
Hosting
Upload a built web game; get an immutable version on play.0x.limo with a swarm manifest and torrents built for you.
Tracker
A WebTorrent-style tracker. It introduces peers to each other and relays the WebRTC handshake so they can connect through NATs.
Seeders
Always-on peers for every published version, so a swarm is never empty, even for the first player.
Broadcast service
A game server sends each update once; it is signed and forwarded player to player down latency-aware trees.
Hosted game servers
Your Node.js server (socket.io, Colyseus, ws) in a locked-down sandbox next to the broadcast service.
World gateways
Sit in front of live Minecraft-protocol worlds and turn chunk data into hash references that players fetch from neighbours.
Launcher and native runtime
Install builds through the swarm, staged and resumable, and seed while open. Native clients join the same swarms as browsers.
The content swarm: how a file reaches a player
- Publish. Every file is hashed with SHA-256; the hash is its name. The manifest maps each path in your game to
{sha256, infohash, size}. Torrents are deterministic (256 KiB pieces), so the same bytes always make the same torrent on any machine. Only files the service doesn't already have are uploaded. By default every file of 16 KiB or more goes on the swarm. - Seed. An always-on seeder joins the swarm for every published version, so the first player already has a peer.
- Meet. The player's page announces to the tracker, which relays the WebRTC handshake. Public STUN servers help peers find a way through their NATs; when no direct path exists, the pair connects through our TURN relay,
turn.0x.limo(UDP, TCP, and TCP on port 443 for networks that allow only web ports). - Intercept. A service worker sits under the game. The game's own loaders (fetch, GLTF, audio, WebAssembly streaming) don't change. For each listed file, the worker asks the page's swarm host to fetch it from peers, including byte ranges.
- Verify. Whoever served the bytes, they are checked against the manifest's SHA-256 before the game sees them. Bad data is thrown away and never re-shared. Cached copies are checked again when read.
- Fall back. Peers go first. A fetch that is too slow from its first byte, or runs past a budget that grows with the file's size, switches to the origin. Small files, files outside the manifest and the 0x runtime itself always come from the origin, and without a service worker the game loads exactly as it would anywhere else.
- Pass it on. Fetched files are kept in the browser's storage and seeded to the next players while the page is open, within an upload cap per page.
Native clients speak the same protocol, so a desktop launcher and a browser can share a swarm. Paid content can travel as AES-256-GCM ciphertext: peers verify and seed it without the key, and the key is released per file only to owners. Publishers can also sign their builds (Ed25519), and clients refuse rollbacks and unknown keys.
Live worlds: players serve each other the map
For large shared worlds (Minecraft-protocol servers such as our Earth, War and Los Santos worlds), a gateway sits in front of the unchanged game server and cuts the server's outbound traffic two ways.
Chunks by reference
Instead of sending a chunk's data, the gateway sends its coordinates and SHA-256. The client checks its own cache, then asks up to three nearby players (up to six neighbours within 12 chunks are linked over WebRTC), and takes the first answer that matches the hash. The gateway answers anything peers can't, at the latest after 2 seconds.
Fan-out trees for live updates
Every 50 ms, the gateway takes the entity, sound and particle updates that many players would receive identically, frames them once and signs each frame with Ed25519. It sends the frame to the roots of a tree; each player forwards to at most three others, at most four levels deep. Things that must be exact and personal (your own position, inventory, chat, block changes) always come straight from the gateway.
- Latency-aware trees. Trees are built from measured round-trip time, loss and each player's upload budget, with a backup parent for every member. A new tree replaces the old one only if it is at least 15% better.
- Repair. A gap is asked from the backup or parent after 60 ms and from the gateway after 400 ms (it keeps the last 100 frames). Players who fall behind get frames directly for a while.
- Reputation. Bad hashes and unsigned frames are reported immediately. Two independent players in good standing must agree before a peer is excluded: 5 minutes, doubling up to an hour. Exclusion only removes someone from forwarding; they keep playing normally.
- Your connection comes first. Native players measure their own uplink queue and cap what they serve to others (1 MiB/s by default, never below 64 KiB/s), so serving the map never makes their own game lag.
- Kill switches. Both the gateway and the client can turn offload off; any peer failure falls back to the direct path.
Multiplayer without the bandwidth bill
The same signed-frame, tree, repair and reputation machinery is available to any game through the broadcast service. Your server registers its players and their interest groups, then calls broadcast(group, bytes) once; the service signs it and players carry it to each other in order. With @0xlimo/net, a socket.io or Colyseus game adopts it in one line on the server and one on the client, and a player who can't join the trees still gets every broadcast over the game's normal socket.
If your game has its own Node.js server, 0x deploy-server runs it for you in a sandbox: its network is loopback only, with just the broadcast service and the platform API passed in; a read-only filesystem, no capabilities, an unprivileged user and CPU, memory and process limits. It is restarted automatically if it crashes; in our tests four players were back in the game about five seconds after the server was killed.
Trust model
| What travels | How it's protected | What a bad peer can do |
|---|---|---|
| Game and site files | SHA-256 from the manifest, checked on arrival and when read from cache; native pieces checked per piece | Delay or withhold. You fall back to other peers or the origin. |
| World chunks | SHA-256 sent by the gateway | Delay or withhold. The gateway answers after 2 s at most. |
| Live updates | Ed25519 signature on every frame | Drop or stall frames: repaired from the backup, parent or gateway; the peer is reported and excluded. |
| Paid content | AES-256-GCM; key released only to owners | Seed the ciphertext, which is useless without the key. |
| Published builds | Optional publisher Ed25519 statements; rollback refused | Nothing: unknown keys and older builds are refused. |
Developer sites are served from play.0x.limo, never from the origin that holds sign-in tokens. Hosted game servers there run with a sandbox content policy and never receive players' cookies or authorization headers. Programs and installers are refused at upload. As with any peer-to-peer system, peers you exchange data with can see your IP address.
Measured
From the live-world rollout (lab and staging test runs, then production on 2026-10-09):
| Test | Result |
|---|---|
| Latency-aware vs plain trees, 12 players on emulated networks | p95 323 → 193 ms (−40%) |
| Same, staging | p95 313 → 200 ms (−36%) |
| A parent player killed mid-stream: worst gap for the others | 53–54 ms |
| 20% of players replaced every minute: repair traffic | ≤ 0.46% |
| Stalling, dropping, corrupting, slow and lying peers: time to exclusion | 1.0–5.1 s |
| Honest players wrongly excluded in 30 minutes of churn | 0 |
| 500 players through one gateway: added p99 latency | 2–4 ms |
| Serving player's own p95 while serving others | +1 to +2 ms |
| Production smoke test: chunks a new player got from a neighbour | 1132 of 1169 |
| Hosted web game, second visitor: bytes from the origin for swarm-listed files | 0 (typical run) |
Current limits
We'd rather you hear these from us. As of October 2026:
- One TURN relay, in Europe. Players who can only connect through it get higher latency from farther away; if it is down they load from
play.0x.limoinstead of from peers. - Browsers seed only while the page is open, and they can't measure their own uplink queue, so the "serving costs you nothing" guarantee covers native players.
- Rarely played files depend on the origin when nobody who has them is online.
- Peers sometimes lose the race. In our tests about one run in three, one file still came from the origin; that's the fallback working, not a failure.
- Bring-your-own Minecraft servers (
0x paper) aren't open on 0x.limo yet. - No automatic matchmaker or region-based server choice yet; the SDK is version 0.