PYTHON · NUMPY

The Swarm Bench

The same controller flies the whole fleet through a deterministic WGSL solver on your GPU. Why is determinism the point?

Fly the whole fleet through the real deterministic WGSL solver, and understand why the same controller flies the aircraft.

01Challenge

Everything so far ran on toy models. Now the fleet is stepped by the actual batched quadrotor kernel on your GPU, the same solver, deterministic to the bit, whose one compiled controller also flies a real Pixhawk. Run it, read the swarm, and connect the loop end to end.

Predict firstThe same controller flies the whole fleet through a deterministic WGSL solver on your GPU. Why is determinism the point?

02Model

This is where the course's pieces converge. The physics here is the production WGSL solver itself, stepping thousands of quadrotors in parallel on your GPU. It is deterministic where it counts: the trajectory is fixed-point and reproducible, so a graded run replays identically and a result can be trusted. And the controller is the seam: the exact same compiled module that flies this fleet is built to drop onto a real aircraft over MAVLink, with only the I/O shim changing. Develop here, deploy to metal, one binary. That is the whole thesis of the course, made literal.

03Guided practice

Worked: open the live bench and watch the real solver fly the fleet. Faded: relate the batched envs to your consensus rule. Independent: reason about what stays identical from sim to hardware (the controller) and what changes (the I/O shim).

04Feedback

PASS WHEN You connected the course end to end: real deterministic physics, and one controller that flies both the sim and the aircraft.

If your run fails, check:

Open the live bench (swarm-live) to see the real WGSL solver step the fleet on your GPU.
The controller is a pure state→command function; the sim and MAVLink hosts differ only in the shim around it.

05Retrieve & space

What is identical from sim to hardware, and what changes? (The compiled controller is identical; only the I/O shim changes.)
Why does determinism matter for grading? (A bit-exact trajectory can be replayed and scored the same everywhere.)
Why is running the real solver the pedagogical win? (Every student runs the real solver, on any device.)
What lets one airframe model load across simulators? (Standard robot descriptions, URDF and MJCF, the interchange formats MuJoCo, Isaac, and ROS toolchains all read.)

06Mastery & project

Runs the real deterministic solver and articulates the one-binary sim-to-real control seam (L4: connect the full perceive-simulate-act loop across sim and hardware).

The capstone: extend the controller and coordination onto the live swarm, then compile the same module to run on a Blue-UAS-aligned airframe.

GO FURTHER · THE LIVE PLAYGROUND

Open the Digital Twin lab ↗ · live fleet + a bit-exact determinism panel (record/replay)

← Formation Without a Leader Back to course →

PYTHON · NUMPY

The Swarm Bench

The live WebGPU bench runs the real solver, open it alongside this cell, which recaps the sim-to-metal contract.

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you