Inspiration
Two things inspired us to take on this problem.
First, wildfires are personal for us. Last summer, one of our team members spent the summer interning on the west coast of Canada, where devastating wildfires were burning. Seeing the damage up close made us want to work together on technology that helps systems under pressure, and wildfire response, where communication is often the first thing to fail, felt like the right place to start.
Second, the project let us combine our skills. Our team brings together computer scientists, mathematicians and physicists, and this challenge used all of those backgrounds. We built mathematical and logical algorithms, built the system from the ground up, and designed the project as a whole, from the fire physics to the drones’ decision-making.
What it does
HotDrones is a simulation of a firefighting drone swarm that keeps working when communications fail. A wildfire spreads through hilly pine forest towards a village, and ten drones carry water from lakes to the fire front. Hills, distance, smoke and blackout zones cut their radio links, and the home base can go offline.
There is no central controller. Each drone keeps its own private map of where it believes the fire is and decides for itself what to do. When drones can talk, they merge their maps and agree who fights where, so they don’t all pile onto the same spot. When they can’t, each drone estimates where its lost teammates are and keeps working. A drone that knows of no fire goes home for the base’s map, and if there still isn’t one, it scouts areas nobody has seen lately.
You can try to break it. In the live 3D view you can start fires, drop blackout zones, cut the base radio and crash drones. The server then replays your scenario against every coordination mode and ranks the nastiest ones on a public challenge board.
How we built it
HotDrones is a TypeScript simulation with no graphics code, so the same code runs in the browser and headless in Node for big experiments. Runs are seeded, and fire randomness is separate from drone randomness, so every approach faces identical fires. One rule shapes everything: drones never read the true world. Each has its own belief map, where the newest observation wins when drones meet. A comms layer decides who can talk (radio range, hills, blackouts, optionally smoke), and a single setting swaps the coordination mode while everything else stays the same.
Fire spreads by a probability built from fuel, wind, slope and severity, so it races downwind and uphill. Drones turn their map into task zones along the fire front, scored by threat to the village. Battery and damage limit how long they can fly, and a drone with no known fire fetches the base’s map or scouts.
The five coordination modes we compare:
- Central control. The base assigns every drone it can reach. Fast and strong with good radio, but drones out of contact must fly home for orders, and if the base goes offline nobody gets any. No coordination. Each drone goes for its best zone and ignores teammates, so they pile onto the same fire.
- Swarm. A decentralised auction. Drones bid on zones (value divided by time to reach it), publish claims to teammates in contact, and skip zones that are already full. A particle filter guesses where lost teammates are, so their claims count for less the longer they stay silent. It works with no contact at all.
- CBBA. The same auction, but each drone plans a bundle of several zones ahead. If it’s outbid on one, it drops everything planned after it, and the group repeats until everyone agrees.
- Unified stack. CBBA plus four upgrades: Delay-tolerant networking: observations are stored in bundles and carried by drones across gaps in the network.
- Event-triggered sending: drones only send changes worth their bandwidth cost, under a hard budget. Covariance intersection: maps are fused with uncertainty tracked, so they’re never overconfident. Learned zone priorities and predictive flight: zone values adapt during the run, and each drone picks headings that avoid smoke, fire and teammates.
The front end is an isometric three.js view built with Vite. A Node server feeds Tiger Data (telemetry), Gemini (AI incident commander), ElevenLabs (radio voices) and MongoDB Atlas (scenario sharing and the challenge board), deployed with Docker, Caddy and Vultr.
Challenges we ran into
Keeping the comparison fair. To show that decentralised coordination beats central control, every approach had to face exactly the same fires. We separated the random number generators for fire and for drones, so a change in drone behaviour can’t change the fire.
Making drones coordinate without knowing the truth. Drones can only act on their own maps, which go stale or disagree after a blackout. We had to decide how to merge conflicting information and how to handle teammates who go silent.
Telling a crashed teammate from a quiet one. A drone out of contact might be fine or destroyed. The particle filter makes a recently lost teammate count as probably still working, and gradually stops counting one who has been silent for a long time.
Dealing with complexity. Unified mode combines several algorithms that feed into each other. Keeping the runs deterministic and the per-tick cost reasonable took care.
Protecting past results. Because the simulation grew over time, we kept a frozen version of the original 2D results and a check that proves the new code still reproduces them exactly.
Accomplishments that we're proud of
We love the graphics and design of the project
We built our own algorithm combing the best features from all and implementing our own ideas
A swarm that holds up as communications get worse. In our 30-map test at normal radio range, the swarm lost the village in 13% of runs, against 73% for central control.
An honest comparison across several coordination approaches on identical fires, including cases where central control does just as well, such as perfect comms.
A decentralised design that you can see and hear. Drones play in time when connected and drift out of tune when cut off.
A full pipeline around the simulation: live dashboards, an AI commander, a shareable challenge board, and one-command deployment.
What we learned
Resilience comes from design, not just from handling errors. A system that never depended on a hub doesn’t fail when the hub disappears.
Decentralisation costs little when things go well but pays off a lot when they don’t. With perfect comms, our swarm and the central controller did about equally well.
Honest uncertainty matters. Tracking how stale or unsure each belief is, and not trusting teammates’ claims forever, prevented mistakes that a simpler “last known position” approach would make.
Fair experiments are hard. Reproducible seeds, separated randomness and the same fires for every mode were what made the results believable.
Good visualisation helps with debugging as well as presenting. Being able to open a single drone’s own map showed us where its beliefs had gone wrong.
What's next for HotDrones
Fire forecasting. Each drone could run the fire model forward from its own belief and target where the fire will be, not where it is now.
Real terrain. Using elevation data from a real wildfire-prone area.
Beyond fires. The same ideas apply to drone light shows, warehouse robots, search and rescue, and teams of AI agents solving parts of a large problem.
Implementing different fire-fighting methods and systems.
Built With
- caddy
- css3
- docker
- elevenlabs
- google-gemini
- html5
- javascript
- mongodb-atlas
- multi-agent-systems
- node.js
- postgresql
- three.js
- tiger-data
- typescript
- vite
- vultr
- webgl
- websockets