Landing Page
Lobby
Planning Stage
Storm Simulation
Storm Simulation
Results Score
Results Leaderboard
Results Debrief
Town planning information for city planners based on aggregated games from users
NFT for winning Mayor
Verification on chain with Solana
Public data gathered on chain

Mayday Mayor

What if the best disaster-planning meeting your city ever held looked more like a multiplayer game night?

Mayday Mayor turns a real city into a live disaster strategy game. Players get the same constrained problem emergency planners face: limited money, limited infrastructure, and thousands of people who need to get to safety before the city starts failing.

But every decision players make becomes something more valuable: structured public input about how residents believe their own city should prepare.

The result is a game people actually want to play, a crowdsourced planning system cities can learn from, and a public record of knowledge that input anyone can verify.

Inspiration

Cities already have enormous amounts of disaster data. What they often lack is participation.

The most useful knowledge about a city is often not in a dataset. Residents know which underpass floods first, which road everyone actually uses to evacuate, which apartment building has elderly neighbors without cars, and which church becomes a community hub during emergencies.

Cities try to collect that knowledge through surveys and town halls, but very few people participate. Meanwhile, millions of people voluntarily spend hours learning real streets in games like GeoGuessr.

So we asked:

What if contributing to your city's disaster plan felt like playing a multiplayer strategy game?

Instead of asking residents what they think should happen, give them the real city and a limited budget, hit it with a disaster, and see what they do.

Thousands of games then become something a survey could never produce: thousands of complete, structured, comparable disaster plans from the people who actually live there.

## What it does

Mayday Mayor is a multiplayer disaster game built on real city data that turns gameplay into civic intelligence.

Players run for mayor of Raleigh, Miami, New York or San Francisco. They get $10M and three minutes to place shelters, evacuation bus pickups and road protections on the real city map.

Then the disaster hits.

Floodwater spreads through FEMA flood zones. Roads fail. Shelters can become inaccessible. Neighborhoods that stay dry can still become isolated when their routes to hospitals disappear. Thousands of simulated residents either reach safety or become stranded, all on a cinematic 3D map that transforms into a night storm with rising water.

Up to 12 players join through a QR code, plan simultaneously, and watch the disaster begin across every screen at the same moment.

While it happens, Gemini generates a live disaster-news broadcast voiced by ElevenLabs in English or Hindi. The AI can be dramatic, but it cannot invent facts: every number comes from the simulation engine and is validated before narration.

At the end, players see how they performed against the best plan our optimizer found and receive a spoken AI debrief explaining what worked.

### But the game is only half the product

Every finished match is also a complete disaster plan. Thousands of plans become a new dataset showing:

Consensus: where residents repeatedly make the same choice.
Blind spots: important places our model ranks highly but players overlook.
Local knowledge: places residents repeatedly prioritize that our data does not.
Evacuation demand: where players consistently request transit support.
Where to act: interventions ranked by both modeled impact and public preference.

That is the core idea:

real city → human decision → simulated consequence → collective intelligence → planner action

The planner dashboard turns those patterns into map layers and exports them as CSV or GeoJSON for existing GIS workflows.

## How we built it

Geospatial pipeline. We use GeoPandas, Shapely, OSMnx and H3 to combine Census demographics, FEMA flood zones, OpenStreetMap roads and facilities, shelter data and transit feeds.

Simulation. The simulation does more than show what floods. Roads are removed from the transportation graph as hazard stages rise, so a neighborhood can become dangerous even if it stays dry, because it loses access to shelters or hospitals.

Engine and optimizer. A shared TypeScript engine handles scoring, coverage, hospital reachability and hazard progression. An optimizer solves the same constrained planning problem and gives every player a meaningful benchmark.

App and multiplayer. React, MapLibre GL and deck.gl render the experience, while Fastify + WebSockets synchronize multiplayer rooms with server-authoritative timing and scoring. Tiger Data / TimescaleDB stores player decisions, analytics and live readings from 27 USGS and NWS sensors. Continuous aggregates power the dashboard and leaderboard, and columnstore compression reduced one week of gauge data from 11.8 MB to 147 KB, a 98.8% reduction.

Gemini generates the broadcast, debriefs and civic-card content from structured simulation facts.

ElevenLabs voices the anchors and narrator.

Solana provides the public audit trail. Every plan is fingerprinted and anchored on-chain, and significant collective findings become civic signals. Players who helped reveal them receive non-transferable civic cards.

## Challenges we ran into

Modeling who can actually escape. The hardest problem was modeling who can get out, not simply what floods. A dry neighborhood can still become trapped if every road around it fails, so we modeled the road network as a changing graph and recomputed accessibility at every hazard stage.

Fair scoring. Early versions let one shelter unrealistically protect huge parts of the city. We added drive-time limits, shelter flooding, bus walking-distance constraints and overlapping-coverage handling, then built the optimizer so every score is compared against what was actually achievable.

Exciting AI without hallucinations. We needed the broadcast to feel exciting without ever inventing a fact. The engine computes the truth first, Gemini only tells the story around it, and every numerical statement is validated before it is spoken.

Real trust, not a blockchain demo. We wanted Solana to provide actual trust rather than simply being an integration. Plans are canonicalized, hashed and anchored with verifiable proofs, and civic-signal state persists across server restarts, so the public history cannot accidentally become misleading.

And we built all of this for four cities, with four developers, in 24 hours.

Accomplishments that we're proud of

We did not want to build another GIS dashboard. We built:

a multiplayer strategy game on real city infrastructure,
a dynamic disaster simulation where transportation networks actually fail,
an optimizer benchmarking every player's decisions,
a system that converts gameplay into structured planning data,
a planner dashboard separating consensus, blind spots and local knowledge,
a bilingual AI disaster broadcast grounded entirely in simulation facts,
and a verifiable public record of resident input.

The part we are most proud of is that the integrations are not separate demos. They form one loop:

real city → player decisions → disaster simulation → collective intelligence → planner action → public proof

What we learned

We started out thinking this was a disaster-data problem. It is really an engagement problem.

The people with the richest local knowledge are often the least likely to attend a planning meeting or open a GIS portal. So instead of asking people to participate more, we changed the incentive:

Make the problem fun. Make the tradeoffs visible. Make people compete. Then structure what they produce so planners can actually use it.

What's next

Next, we want to drive scenarios from live river gauges during real storms, add dedicated heat and earthquake models, and pilot Mayday Mayor with planners on a real neighborhood decision.

The bigger vision is not limited to disasters: