A Live WebGPU Planet With No Backend

Most database demos are to-do lists. I wanted to find out what happens when you put one under real load — so I built a planet.

OVGrid is a cube-sphere planet you explore as an avatar, right in your browser: procedural terrain, weather, vegetation, day/night, real-time multiplayer presence, and land you can own and trade on-chain. It runs at real scale on WebGPU.

▶ Play it live (no install, no account): https://world.ovgrid.com

But the rendering isn't the interesting part. The interesting part is that there is no backend. No game server, no API, no socket server. A single distributed database — GenosDB — drives the entire live state of the world. This post is about how that works.

First, the planet: Floating Origin

A planet is 795 km in radius. GPUs work in 32-bit floats, which run out of precision long before you get that big — geometry jitters, z-fighting explodes, the avatar shakes. The fix is Floating Origin:

The CPU holds every world coordinate in Float64 (full precision).
Each frame, positions are rebased relative to the camera and only the small camera-relative deltas are handed to the GPU as Float32.

The camera is effectively always at the origin, so the numbers the GPU sees stay tiny and precise — jitter-free all the way down to street-level LOD. A dynamic quadtree on the cube-sphere subdivides terrain near you, and a GPU-baked height grid gives exact ground for collision and physics. (Full write-up: floating-origin-guide.md.)

That's the foundation. Now the twist.

The twist: a database is the backend

Live multiplayer worlds usually need a server: something authoritative that clients connect to, that holds state and relays updates. OVGrid has none. Instead, every client runs GenosDB, a serverless, peer-to-peer, real-time graph database, and the world is the database.

Here's the capability map:

What you see in the world	What GenosDB is doing
Other players appear as animated avatars at the right position, altitude and animation	P2P presence over WebRTC (`GenosRTC`), synced ~12 times a second — no game server
The land map and the marketplace update live as data changes	Reactive reads (`db.map`) — the UI subscribes to a query and re-renders on every change
Land and assets you own, read instantly even offline	On-chain mirror — Polygon is the source of truth, GenosDB caches it for fast, offline, reactive reads
Sign in with biometrics or a seed phrase; actions are signed	Decentralized identity + RBAC via the Security Manager (WebAuthn / BIP39)

Reactive reads: the UI never polls

The land map and the on-chain marketplace are different frontends that read the same database the same way — a live query with a callback that fires on every change, whether the change came from this peer or another:

// Subscribe once. The callback re-fires whenever matching data changes —
// locally OR from a remote peer. No polling, no manual refresh.
db.map({ query: { type: 'parcel' } }, ({ id, value, action }) => {
  renderLandMap()   // re-render the 3D world on each change
  // ...and the marketplace subscribes to the very same data
})

Broadcasting your avatar is just a write:

// Position, yaw and animation, ~12 Hz. Peers receive it and animate your avatar.
db.put({ type: 'presence', pos, yaw, anim }, `presence_${myId}`)

The pattern I'm proudest of: the read layer never changes

A parcel of land might be claimed locally (instant, optimistic) or minted on-chain (an ERC-1155 token on Polygon). Two completely different write paths — one is a local DB op, the other is a blockchain transaction confirmed over minutes.

And yet the world reads both the same way: a db.map subscription. A sync layer mirrors the chain into GenosDB, so the 3D client never waits on an RPC, never hits the chain on the render path, and works offline. The blockchain is the source of truth; GenosDB is the abstraction that makes it feel instant.

What "no server" actually means

The honest question is: if there's no backend, how do peers find each other?

Transport: WebRTC data channels, peer-to-peer.
Signaling: Nostr relays — a decentralized signaling layer, so there's no central matchmaking server either.
Conflict resolution: a Hybrid Logical Clock orders concurrent writes deterministically, so peers converge without a coordinator.

The result: open two browser tabs, walk around in one, and your avatar appears and moves in the other — with nothing running in between but the open internet.

It's open source — and it documents itself

OVGrid is fully public:

→ https://github.com/estebanrfp/ovgrid

A couple of things worth a look:

Every tunable in the world — terrain noise, cloud layers, ocean, lighting, weather, vegetation — is documented parameter-by-parameter in docs/configuration/.
The repo is indexed by DeepWiki, so you can ask the codebase questions in natural language.

If you've ever wanted to see a serverless, P2P, real-time database do something harder than a to-do list — go fly around a planet, then read how a single DB holds it all together.

Play: https://world.ovgrid.com · Code: https://github.com/estebanrfp/ovgrid · Database: https://github.com/estebanrfp/gdb