0x

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.

SHA-256every file is named and checked by its hash, whoever sent it
Ed25519every live update is signed once by the server; players forward it
−36 to −40%p95 delivery latency with latency-aware trees vs plain trees
1–5 sto exclude a cheating or stalling peer in adversary tests

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.

0x SERVICES (authority: hashes, manifests, signatures, fallback) API + pushaccounts, store Hostingimmutable versions Trackerpeers meet here Seedersalways-on peers Broadcast +world gatewayssign live updates player player player player solid: bytes between players (WebRTC) · dashed: small control messages and fallback
The services stay small and authoritative; the heavy traffic runs between players.

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

Developer0x publish / upload Hostinghash every file, buildmanifest + torrents Seederfirst peer Trackerintroductions Player's browserservice worker interceptsthe game's own requests SHA-256 checkwrong bytes aredropped, never shared Other playersWebRTC, each onere-seeds what it has Originfallback
Publish once; players fetch from the seeder and from each other, check every file, and fall back to the origin when peers are slow or absent.
  1. 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.
  2. Seed. An always-on seeder joins the swarm for every published version, so the first player already has a peer.
  3. 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).
  4. 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.
  5. 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.
  6. 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.
  7. 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.

Game serverunchanged Gatewayhash refs, signed frames root signed frame sent once, forwarded down the tree A chunk, by reference gateway sends {x, z, sha256, len} 1. own cache 2. up to 3 nearby players, first wins 3. the gateway (after 2 s at most) checked against the hash every time
World data by reference from neighbours; entity updates down signed fan-out trees.

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.

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 travelsHow it's protectedWhat a bad peer can do
Game and site filesSHA-256 from the manifest, checked on arrival and when read from cache; native pieces checked per pieceDelay or withhold. You fall back to other peers or the origin.
World chunksSHA-256 sent by the gatewayDelay or withhold. The gateway answers after 2 s at most.
Live updatesEd25519 signature on every frameDrop or stall frames: repaired from the backup, parent or gateway; the peer is reported and excluded.
Paid contentAES-256-GCM; key released only to ownersSeed the ciphertext, which is useless without the key.
Published buildsOptional publisher Ed25519 statements; rollback refusedNothing: 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):

TestResult
Latency-aware vs plain trees, 12 players on emulated networksp95 323 → 193 ms (−40%)
Same, stagingp95 313 → 200 ms (−36%)
A parent player killed mid-stream: worst gap for the others53–54 ms
20% of players replaced every minute: repair traffic≤ 0.46%
Stalling, dropping, corrupting, slow and lying peers: time to exclusion1.0–5.1 s
Honest players wrongly excluded in 30 minutes of churn0
500 players through one gateway: added p99 latency2–4 ms
Serving player's own p95 while serving others+1 to +2 ms
Production smoke test: chunks a new player got from a neighbour1132 of 1169
Hosted web game, second visitor: bytes from the origin for swarm-listed files0 (typical run)

Current limits

We'd rather you hear these from us. As of October 2026: