Drone Show Simulator
An interactive 3D drone-swarm simulator. Watch hundreds of drones morph between formations under real physical limits — max acceleration, minimum separation, and wind — and see why a show succeeds, smears, or ends in collision.
A drone light show looks like magic: five hundred points of light dissolve from a sphere into a dragon into a logo, holding each shape in mid-air. It is tempting to think of it as a particle animation — and the visual really is just points moving between positions over time.
But every one of those points is a physical quadcopter with a battery, a top speed, a maximum acceleration, and a bubble of air around it that no other drone may enter. The choreography you design is a wish. Whether five hundred real aircraft can execute it — in wind, without colliding, before the music hits the next beat — is a physics problem.
This simulator runs that physics. Drones launch from a pad and fly to a target formation under the limits you set. In Spectacle mode it just looks cool. In Simulation mode you can tighten the limits, add wind, and watch a show fall apart.
200 drones fly the optimized assignment with generous physical limits, so formations land cleanly. Pick a formation above, or let auto-cycle run.
Switch to to add wind, tighten limits, and watch shows fail.
What you're actually looking at
The rendering is the easy half — points with a position and a color. The interesting half is everything constraining where those points are allowed to be:
- Each drone is acceleration-limited. It can't teleport to its target; it has to speed up and slow down. Push the transition time too low and drones are still in flight when the formation is supposed to be complete.
- Drones can't share space. Every aircraft carries a minimum-separation bubble. If two flight paths cross within that radius while either is still in transit, that's a collision risk — in the sim those drones flash red and keep flying, but the breach is counted against the show.
- Wind is a disturbance the drone must fight. A drone corrects against wind using the same limited acceleration it uses to fly. When the wind speed approaches the drone's top speed, it simply runs out of authority to hold position, and the formation smears.
- Drones are not identical, and they have "health." Each has its own drag (how hard the wind pushes it) and its own structural tolerance. Think of tolerance as HP: air pushing harder than a drone can withstand drains it; calmer air regenerates it. When HP runs out the drone fails — loses control and tumbles out of the sky (red), and if it hits the ground it crashes (grey). A failing drone that strikes a healthy neighbor dumps damage into it, so failures cascade. But it's not permanent: if conditions calm below a drone's tolerance, it heals, and a crashed drone can relaunch and rejoin the formation. This is why real chaos isn't a uniform push — it's the weakest units giving way first, sometimes recovering, sometimes taking others down.
The visual is particles. The simulation is a constrained multi-agent motion problem. That gap — between the choreography and what the hardware can do — is the entire engineering discipline of drone shows.
You can follow any individual drone by its light: dim means it hasn't reached its assigned position yet; full color means it's there; orange is a separation near-miss; red is a drone that has structurally failed.
The hidden problem: assignment
Switch to Simulation mode and toggle Naive vs Optimized assignment. Watch the paths.
When a swarm morphs from formation A to formation B, something has to decide which drone flies to which point. This is not obvious, and getting it wrong is dangerous:
- Naive assigns drones to target points by index — drone 0 to point 0, drone 1 to point 1, and so on. The result is a tangle of crossing flight paths, because nearby drones get sent to far-apart targets. Crossing paths are exactly where collisions happen.
- Optimized matches each drone to a nearby target, minimizing total travel and path crossings. The transition looks calmer and is far safer.
This is a real and classic problem — the linear assignment problem. For a perfect solution you'd use the Hungarian algorithm (O(n³), fine for a few hundred drones); above that, fast approximations like greedy-nearest or auction algorithms take over. This simulator uses greedy-nearest, which is why very large counts under a tight separation can still produce a few crossings.
How a real show is built
Professional shows are not flown by real-time swarm intelligence. Every trajectory is computed and validated offline, then uploaded to each aircraft, which flies its own pre-planned path timed to a shared clock.
The open-source reference for this is Skybrush. You design the show in Blender, and the toolchain checks it against the very constraints this simulator exposes — minimum distance, velocity and acceleration limits, altitude bounds — before a single drone leaves the ground. One detail worth knowing: real trajectories are stored not as dense per-frame samples but as polynomial/Bézier curve segments, because a polynomial gives you exact velocity and acceleration for free — and those derivatives are precisely what the safety check consumes.
| Stage | What happens | Failure caught here |
|---|---|---|
| Design | Artist authors formations and timing | — |
| Assignment | Software matches drones to targets between formations | Crossing paths |
| Trajectory generation | Smooth curves fit through the waypoints | Jerk, speed/accel violations |
| Validation | Every pair checked for separation; every drone for limits | Collisions, out-of-envelope motion |
| Upload & fly | Trajectories sent to aircraft; flown to a shared clock | Wind, GPS error (live) |
Who should care, and how to think about it
This is a clean, low-stakes window into multi-agent motion planning.
The "arrive" steering you see — desired velocity tapering as a drone nears its target, capped by a maximum acceleration — is a basic control law that shows up in robotics everywhere from mobile robots to spacecraft docking. The assignment toggle is the linear assignment problem (Hungarian / auction). The separation bubble is the core of collision-avoidance and ties directly to reciprocal velocity obstacles (RVO/ORCA) used in real swarms and crowd simulation.
The honest simplification here: real drones don't have a car-like turn radius — they translate in any direction and yaw in place — so the limiting constraint is acceleration, not turn rate. This sim models that correctly. What it omits: downwash interaction between close drones, battery dynamics, and per-axis thrust asymmetry.
The structure here is a swarm of agents each tracking a target under constraints — the same shape as many simulation and RL environments.
Notice the data model: everything is structure-of-arrays (flat typed arrays for position, velocity, status), which is what keeps several hundred agents updating at 60fps and maps one-to-one onto a GPU instanced mesh. The assignment step is a bipartite matching; the collision check is a spatial-proximity query (here brute-force O(n²), which a spatial hash would replace at higher counts).
If you've worked on multi-agent RL, this is a hand-written policy (greedy assignment + arrive controller) rather than a learned one — useful as a baseline and as an intuition pump for what a learned policy would have to discover: that minimizing path crossings during transitions is what keeps the swarm safe.
Drone shows are displacing fireworks for a reason: they're reusable, programmable, quiet, and leave no debris. The global market has grown quickly, with shows now running hundreds to thousands of aircraft.
The cost structure is mostly fixed assets (the drone fleet) plus per-show design and operations labor — not consumables like pyrotechnics. That changes the economics: once you own the fleet, the marginal cost of another show is software and a flight crew. The constraints in this simulator are also the operational risk surface: wind limits are the most common reason a show is delayed or cancelled, because (as you can see by pushing the wind slider) beyond a threshold the formation simply can't hold.
The thing that makes a drone show hard is the thing you can't see: the empty space each drone needs around it.
A formation isn't just "put lights at these positions." It's "move five hundred objects to these positions at the same time without any two ever touching." That's a surprisingly deep problem — the same family of problems as routing traffic, scheduling, and even how proteins fold without tangling. Toggle the naive assignment and tighten the separation, and you can watch the difficulty appear as red flashes.
Wind is the other invisible factor. A drone holding position in wind is not resting — it's constantly fighting, spending its limited power to stay put. Push the wind past what it can fight, and the shape dissolves. Real shows watch the forecast for exactly this reason.
Reading the controls
| Control | What it does |
|---|---|
| Spectacle / Simulation | Spectacle auto-cycles formations with generous limits; Simulation exposes the physics sliders and a pass/fail verdict |
| Formation buttons | Jump the swarm to a target shape (sphere, Big Dipper, swimming koi, a word, the tumbling Q3D cube, or Bad Apple) |
| Bad Apple | A grid of drones plays the Bad Apple!! silhouette video purely through their brightness — the "colour by frame" trick. Crank the Drones slider up for more resolution. |
| Expand (⤢) | Top-left of the viewer — opens a 90% fullscreen dialog; Esc or click the backdrop to exit |
| Naive / Optimized | Switch how drones are matched to target points — watch the path tangle change |
| Max speed / accel | The drone's physical envelope; lower accel = sluggish, can't form in time |
| Min separation | The collision bubble radius — also expands or tightens the whole formation so neighbours hold that spacing |
| Wind speed / direction | The steady mean flow; the blue streaks drift along it, the ground grass bends to it, and the drones lean and sway into it |
| Gust | Turbulence strength — a swirling, divergence-free flow field (curl noise) carried downstream by the wind. You see it in the blue flow streaks bending and clustering, and it shears the formation |
| Drone toughness | Scales every drone's structural tolerance to wind; lower it to trigger failures and cascades sooner |
| GPS jitter | Cosmetic position noise — what real positioning error looks like |
| Transition time | How long the swarm has to complete the formation before it's judged |
| Drone color | Dim = in transit · full color = arrived · orange = separation breach · red = structurally failed · grey = crashed on the ground |
| Verdict | SUCCESS ≥97% formed · SMEARED 80–97% · INCOMPLETE under 80% · COLLISION drones breached or were lost |
The margin in the verdict is the closest approach between any two drones divided by the separation bubble: above 1 is safe, below 1 means a breach is happening.
What this simulator doesn't model
| Omitted | Why it matters in reality |
|---|---|
| Aerodynamic downwash | Drones flying directly above one another disturb each other's airflow; real shows enforce vertical spacing rules beyond simple separation |
| Battery & time budget | Every show has a hard flight-time limit; complex choreography drains batteries faster |
| Curve-based trajectories | This sim steers live; real shows fly pre-validated polynomial curves, which guarantees the limits are never violated mid-flight |
| Variable-detail formations | A fixed fleet can't add drones for a detailed frame — high-detail shapes (e.g. playing a video) are constrained by drone count, and spare drones must be parked dark |
| Wind as a 3D field | Real wind varies with altitude and gusts in structured ways, not as the uniform push modeled here |
Glossary
| Term | Definition |
|---|---|
| Formation | A target set of positions the swarm flies into and holds |
| Assignment problem | Deciding which drone flies to which target point; minimizing total travel and path crossings |
| Hungarian algorithm | An O(n³) method that solves the assignment problem optimally |
| Greedy-nearest | A fast approximate assignment: each drone claims its nearest unclaimed target |
| Arrive steering | A control law where desired speed tapers near the target so the agent stops smoothly |
| Minimum separation | The radius of empty space each drone requires; breaching it is a collision |
| Smear | Loss of formation sharpness when drones can't hold position (usually wind) |
| Downwash | The column of air pushed down by a drone's rotors, which disturbs aircraft below it |
| Structure-of-arrays (SoA) | Storing each attribute in its own flat array (vs. an array of objects) for speed and GPU-friendliness |
.skyc | Skybrush's drone-show file: a container of per-drone trajectory curves, light programs, and timing |
Sources and further reading
- Skybrush — open-source drone show suite; the studio-blender designer and libskybrush trajectory format are the practical reference for how real shows are built and validated
- drone-show topic on GitHub — open implementations of swarm choreography and ground-control software
- Linear assignment problem / Hungarian algorithm — the standard treatment of optimal drone-to-target matching
- ORCA / reciprocal velocity obstacles — the collision-avoidance framework behind real-time multi-agent navigation
Data Center Cooling
A finite-difference heat diffusion simulation of a server room. Racks generate heat proportional to load; CRAC units absorb it. Watch thermal gradients form, throttling kick in, and PUE change as you rearrange the room.
Demographics Simulator
Population simulation to understand birthrates, budgets, immigration