Ruvon Swarm Studio 3D

What you're looking at

Each browser tab runs 64 fully simulated drones under the control of a live RuvonEdgeAgent — the same Python runtime that powers payment terminals and industrial IoT gateways — compiled to WebAssembly via Pyodide.

Open multiple tabs from the same sovereign link and the tabs form a private fog network: they elect a leader, divide the formation space, and render a unified swarm with each browser contributing its own slice. Close any tab and the remaining nodes re-elect a new sovereign and recompute the fleet in under a second.

Architecture at a glance

How to use the demo

1. Open the demo in any Chrome or Edge browser (WebGPU required). Firefox support coming when WebGPU ships in stable.
2. Click Launch Drones. 64 drones spool up and fly to the default Ruvon-R formation. This tab is the sovereign — it controls the swarm.
3. Copy the Sovereign Link shown in the top-left panel and paste it into a second tab or window. The second tab joins the mesh as a follower.
4. On the follower tab, click Join Formation. The sovereign expands the fleet to 128 drones and each tab renders its own 64-drone slice of the formation.
5. Add more tabs from the same link. Each adds another 64-drone squad. The formation math scales deterministically — no extra network traffic per drone.
6. Try the 3D Formations panel: Sphere, Helix, DNA, Torus, Vortex, Wave, Cube.
7. Type a command in the Command box (e.g. "form a sphere", "scatter", "land all"). MiniLM matches it to the nearest preset; complex prompts escalate to wllama/Ollama.
8. Close the sovereign tab. The remaining tab detects the departure via GOODBYE broadcast, re-elects itself sovereign, and recomputes the fleet — all in under one second.

Key technology

Sovereignty election

Every tab runs a gossip heartbeat every ~2 s, broadcasting a capability vector (battery, CPU load, RAM, task queue). The mesh scores all pods and elects the highest-scoring one as sovereign.

How split-brain is prevented

• Stable tiebreaker: scores are sorted by (score DESC, pod_id ASC) — all pods converge to the same winner even at identical scores.
• FOUNDING_BIAS (+0.40): the first tab opened gets a score bonus so it naturally stays sovereign while it's alive.
• Fresh election on conflict: if two pods simultaneously claim sovereignty (race after founder closes), both run a hysteresis-free election and the lower-ranking one yields immediately.
• Instant GOODBYE: closing a tab sends a GOODBYE directly on the BroadcastChannel (synchronous, main-thread), so peers re-elect in <1 s instead of waiting for a 15 s stale timeout.

Sovereignty transfer

When a follower is elected sovereign it:

1. Resets its slot to 0 (sovereign is always slot 0).
2. Adopts all currently flying pods as active fleet members.
3. Rebroadcasts the current formation with the corrected slot map.

ruvon-swarm package

The Python workflow logic is packaged as ruvon-swarm and installed inside Pyodide at runtime via micropip. It provides:

• SwarmFormationState — Pydantic state model for formation commands
• DroneCommand workflow — 5-step YAML: ParseCommand → ValidateFormation → BuildIntent → LogFormation → ExecuteFormation
• build_intent step — returns a deterministic seed derived from the workflow ULID, which JS uses to compute formation slices
• mulberry32 PRNG — bitwise-identical implementation in both JS and Python so formation math can be validated server-side

pip install ruvon-swarm

Run locally

git clone https://github.com/KamikaziD/ruvon-swarm
cd ruvon-swarm/examples/swarm_studio
python serve.py          # serves on http://localhost:8081

The local server proxies the Pyodide CDN through localhost and adds the COOP/COEP headers required for SharedArrayBuffer. No installation needed beyond Python 3.9+.