Loading...
Loading
Swarm
π (Anusvara)SN124Overview
Registration Activity
Neuron registration trends
This Interval
0
β burn Β· β PoW
Target / Interval
Loading
Neuron registration trends
Autonomous drone navigation is typically developed and tested behind closed doors using fixed test sets, making it impossible to compare different approaches fairly or prove whose solution is best. There is no public arena where a drone pilotβtrained by anyone, anywhereβcan be objectively scored against competing implementations on fresh, unseeable environments. This lack of transparency and reproducibility slows innovation and leaves the industry without a common benchmark.
Swarm addresses this by creating an open evaluation network where anyone trains a navigation policy (a neural network that controls a drone), submits it for scoring, and watches it compete on a public leaderboard. Every submission is benchmarked against 1,100 procedurally generated worlds across five distinct missionsβall evaluated identically by a distributed network of validators. No memorization is possible because every seed is fresh. The scoring is transparent, reproducible, and enforced by incentives: validators are rewarded for honest evaluation, and miners are rewarded proportional to how much their work advances the frontier.
On Bittensor Subnet 124, validators run a Docker-sandboxed simulator that executes each submitted policy in a depth-camera-equipped drone, measures success, speed, and safety, and aggregates a single benchmark score. Rewards follow King of the Hill mechanics: the current champion and the four most recent past champions of each family earn from that family's allocation, with each king's share tied to the improvement they locked when they took the throne. This structure incentivizes real innovationβnot just copying the current best.
Use cases were auto-generated from the GitHub repository and may not reflect the latest changes.
Swarm Subnet 124 is an open-arena autonomous drone navigation benchmark on Bittensor where miners train drone pilots to compete across five challenge families (Autopilot, Search-and-Rescue, Swarm Autopilot, Swarm SAR, Office Interceptor) on procedurally generated maps. Validators score submissions using a Docker-sandboxed simulator, and rewards are distributed via King-of-the-Hill mechanics that pay the last five champions of each family proportional to their contribution to advancing the family's benchmark score.
Miners train drone navigation policies (neural networks) locally, package them as ZIP files with drone_agent.py entry point, and submit to the Swarm backend via swarm model submit with a hotkey signature. Validators receive submissions, extract and verify them in a Docker container with resource limits (6 GB RAM, 2 CPUs), run the full 1,100-seed benchmark via a Cap'n Proto RPC interface, and score each submission. The benchmark engine (PyBullet physics sim + procedural map generation) evaluates the policy on fresh seeds never seen before.
Validators call reset() between seeds and act(obs) every 50 Hz control step, capturing depth camera, state vector, and optional RGB frames. Scoring computes per-seed success/time/safety terms, aggregates across seeds, and compares to the reigning champion. If the challenger clears the dynamic crowning floor, it becomes the new champion and enters the King-of-the-Hill window.
Validators set network weights based on the five-king formula, feeding emissions to Bittensor. The backend archives every crowned submission and maintains the lineage and window state; validators independently recompute weights to prevent backend manipulation.
This information was auto-extracted from the GitHub repository and may be incomplete or out of date. Always refer to the subnet's GitHub repository for the latest instructions.
Each family (Autopilot 15%, Search-and-Rescue 15%, Swarm Autopilot 20%, Swarm SAR 20%, Office Interceptor 30%) runs 1,100 seeds per 14-day epoch. Validators score submissions on success (landing/hovering/catching), speed relative to a time budget adjusted for search radius or chase distance, and safety (obstacle clearance). A champion's gain is logged-headroom improvement: log((1-prev_score)/(1-score)), capped at 1.0 for the bonus calculation.
Each king's share = 0.7^rank Γ (1 + 0.3Γmin(gain,1.0)) / sum of all window shares within the family. A king stops earning when a sixth new king is crowned (after 5 dethronings). The formula converges across validators without a shared secret: all recompute from the backend's raw kings and family allocations.
The sections above were auto-generated from the GitHub repository and may not reflect the latest changes. View repository
FAQs were auto-generated from the GitHub repository and may not reflect the latest changes.
Holder & total-staked metrics as of 1h ago (hourly snapshot)
CPU speed minimum 2.5 GHz per core, recommended 3.5 GHz. 4 GB minimum swap, 8 GB recommended swap. GPU helpful for model training but not required for running inference.
CPU speed minimum 2.5 GHz per core, recommended 3.5 GHz. 4 GB minimum swap, 8 GB recommended swap. Requires Docker daemon running. 100 GB recommended storage.
Clone the Swarm repository
git clone https://github.com/swarm-subnet/swarm && cd swarm
Create and activate Python virtual environment (requires uv or pip)
uv venv && source .venv/bin/activate
Install Swarm package and dependencies
uv pip install -e . || pip install -e .
Verify installation and environment setup
swarm doctor
Start mining (trains and submits drone models)
cd miner && python neurons/miner.py --wallet.name <your_wallet> --wallet.hotkey <your_hotkey>
Clone the Swarm repository
git clone https://github.com/swarm-subnet/swarm && cd swarm
Install Docker and add user to docker group
sudo apt-get install -y docker.io docker-compose && sudo usermod -aG docker $USER
Create and activate Python virtual environment
uv venv && source .venv/bin/activate
Install Swarm package and dependencies
uv pip install -e . || pip install -e .
Verify Docker, dependencies, sandbox binaries (nsenter, iptables), and compute environment
swarm doctor
Start validator (scores miner submissions and sets network weights)
python neurons/validator.py --wallet.name <your_wallet> --wallet.hotkey <your_hotkey>
