You already made the app.

The next part is one sentence. Point your coding agent at gruve-kit and tell it to make your app multiplayer with Gruve — it earns a tile in your friends' lobby, a backend they can reach across the mesh, and live shared sessions. You don't write any netcode.

The build

Three moves, then a linter says you're done.

1 · Drop in gruve-kit. Clone gruve-kit — it's open source — and hand the folder to your AI assistant. It's written to be read by a coding agent in a single pass: the SDK in JavaScript, Python, Rust, and Go, a linter, and the full contract with the real failure behind every rule.

2 · Announce your app. From the backend that's already running, send one POST — re-sent as a heartbeat — declaring your UI port and any backend ports as named upstreams:

// from your backend (Node, Python, Rust — anything that speaks HTTP) import { announce } from "gruve-sdk"; announce({ id: "myapp", name: "My App", port: UI_PORT, upstreams: { api: API_PORT } });

3 · Route through the SDK. Swap hardcoded localhost URLs for apiBase so calls resolve on whoever's hosting — not the viewer's own machine. Want a shared view? joinSession is the whole surface: subscribe to remote changes, set a key.

const API = apiBase("api") // reaches the host's backend, wherever it runs const session = joinSession() session.state.subscribe((key, value) => { /* apply remote truth */ }) session.state.set("instrument", "ETH/USDT") // LWW per key. that's the netcode.

Then run the linter — gruve doctor <dist> — and it tells you exactly what would break for a remote viewer, or exits clean. That's the whole project: an afternoon's app, social by evening.

Already on the mesh

Real apps, made multiplayer.

These started as ordinary Tauri desktop apps — a web front end over a real backend. That shape is the sweet spot for Gruve: the backend already speaks HTTP, so friends reach it as a named upstream, and the front end already builds to static files, so it serves straight into the lobby.

Doten Tauri · Rust

Drop a raw Dota 2 .dem replay and the match becomes a space-time column — the minimap on the ground, time rising vertically, every kill, death, ward, and rune in its place. Replays parse natively in Rust in under a second.

Gruve fit: the heavy native parser stays on the host as an upstream, and the built UI drops into the lobby — a friend scrubs the same replay without installing a thing.

View on GitHub →

Pharaoh Tauri · AI

An AI audio-drama studio: a story bible becomes a storyboard, then a script, then generated voices, foley, and music — composited and rendered. Drive it by hand in the GUI or by an agent over the headless CLI.

Gruve fit: a stack of Python inference servers behind named upstreams is exactly what the mesh carries across machines, so a collaborator drives the same render farm from their lobby.

View on GitHub →

Oracle Tauri · GPU

A field-simulation lab instrument — define a coil geometry, solve the scalar and vector potentials with FEniCSx, and explore them as interactive 2D heatmaps and 3D volumes. Built for fast hypothesis iteration.

Gruve fit: a GPU/FEniCSx solver too heavy for a laptop tab lives on the host node, while collaborators open the same instrument and read the same fields over the mesh.

View on GitHub →

Start

Make yours multiplayer.

Grab the kit, hand it to your agent, and get your people in. The contract is small on purpose.

gruve-kit on GitHub → Get Gruve