What If 80 Million GeoGuessr Players Role-Played as Mayors and Planned Real Cities for Disasters?

Aum Pandya — Mon, 05 Oct 2026 22:40:45 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

A question we couldn't stop asking

Over 80 million people play GeoGuessr. Around 300,000 of them play every single day, staring at real street corners in real cities, for fun. Players of Cities: Skylines have built almost 40 million simulated cities, deciding where roads go and which neighborhoods get a hospital.

Now think about how a real city decides where its disaster shelters go. A handful of planners, a set of models, and a public meeting where a good turnout is a room of people.

That gap is what our team kept coming back to. People clearly want to make decisions about places. Cities clearly need the knowledge those people carry. Residents know which underpass floods first, which road everyone actually takes to get out, which building has elderly neighbors without a car, which church becomes the place everyone goes when things go wrong. None of that is in a dataset, and surveys don't capture it because almost nobody fills them out.

So our hypothesis was simple:

If even a fraction of the energy people put into map games went into planning real cities for real disasters, planners would get a dataset that doesn't exist today: millions of complete, scored decisions about where to act, from the people who live there.

What the numbers could look like

Every game of our project produces about five located decisions, like where a shelter goes, which road gets protected, and where an evacuation bus should stop, plus a score that says how well those decisions worked against a real disaster model.

If…	Plans	Located decisions
1% of GeoGuessr's players each played 3 games	2.4 million	~12 million
A GeoGuessr-sized daily audience played one round a day	300,000 per day	~1.5 million per day
One city's residents played through a single hurricane season	thousands	tens of thousands, all in one city

These are scenarios, not forecasts. But even the smallest of them is more structured public input than most cities collect in a decade.

Why that data could change how cities plan

Cities already run serious flood, heat and climate models. What those models are missing is people.

Evacuation models make assumptions about how residents behave: which shelter they head for, which road they trust, whether they leave at all. Millions of real decisions made under real constraints are exactly the evidence those assumptions lack.

When many residents keep choosing a place the model doesn't rank, that's a signal worth chasing. Maybe that building is the real community hub. Maybe that road floods earlier than the map says. Local knowledge stops being an anecdote and becomes a pattern a planner can investigate.

And every game is a stress test. Thousands of players running thousands of different plans through the same simulated disaster explore far more of the possible solutions than any planning team could, and show which choices hold up and which fail.

real city → human decision → simulated consequence → collective intelligence → better models and better plans

So we built Mayday Mayor

Mayday Mayor is a multiplayer disaster-planning game built on real city data that turns every game into public input for city planners.

You pick a city: Raleigh, Miami, New York or San Francisco, each facing a different disaster. You run for mayor, alone or in a room where friends join by scanning a QR code. You get $10M and three minutes to place shelters in real public buildings, evacuation bus pickups at real transit stops, and protection on the roads most likely to fail.

Pick a city, pick a disaster: four real cities, each with its own threat.

Three minutes, $10M: shelters go in real buildings, bus pickups at real GoRaleigh stops.

Then the disaster hits. Water spreads through real FEMA flood zones. Roads close. Neighborhoods that stay completely dry suddenly get cut off, because every route to a hospital went under. Thousands of simulated residents either reach your shelters or get stranded, while a live AI news broadcast covers the chaos in English and Other languages, calling out what each candidate did and didn't plan for.

The storm hits. Gemini writes the news, ElevenLabs reads it live.

When the water settles, you see your score against the best plan our optimizer found, where you rank, and a spoken debrief of what worked.

Where you stand: every plan in the city, ranked on the same benchmark.

The debrief, the play's record on Solana, and one click to the planner view.

But the part we care about most happens after you close the tab. Your game was a complete disaster plan, and it joins everyone else's on a planner dashboard that shows:

where to act first, ranked and pinned on the map;
where residents and the data agree, so action has public support;
blind spots, the high-priority places players keep overlooking;
local knowledge, the places players keep choosing that the model doesn't rank;
evacuation demand, where people keep asking for bus pickups, exportable as CSV and GeoJSON for any GIS tool.

What planners see: the data's top places to act, and how rarely residents chose them.

Every plan is also written to Solana, so the public record can't be quietly edited later.

What I learned

I walked in thinking this was a disaster-data problem. I walked out convinced it's an engagement problem. The people with the richest local knowledge are usually the least likely to show up to a planning meeting or open a GIS portal. So instead of asking them to participate more, we changed the incentive: make the problem fun, make the tradeoffs visible, let people compete, and then structure what they produce so planners and modelers can actually use it.

Demo

🌐 Play it: maydaymayor.us
💻 Code: github.com/darshrank/ready-raleigh
🎥 Video: Watch the demo

Partner Technologies

We used four partner technologies, and each one ended up doing a job the product depends on.

Tiger Data: the memory of every decision

Every play, every piece a player places, and a live feed from 27 USGS river gauges plus National Weather Service stations for all four cities stream into Tiger Data hypertables.

What sold us was continuous aggregates in real-time mode. The leaderboard, the crowd's picks per spot per city, and hourly river history all come from them, so a new game shows up on the planner dashboard immediately, with plain SQL and no separate analytics pipeline.

Then we turned on columnstore compression. River gauges produce a lot of rows, so we segmented by gauge and ordered by time:

ALTER TABLE gauge_readings SET (
  timescaledb.enable_columnstore = true,
  timescaledb.segmentby = 'site_no, parameter',
  timescaledb.orderby = 'time DESC'
);
CALL add_columnstore_policy('gauge_readings', after => INTERVAL '2 days');

A week of readings went from 11.8 MB to 147 KB, 98.8% smaller, and our poller kept writing into compressed data without a single change. The only surprise was that the policy's schedule is slow by default, so for the demo we compress due chunks ourselves at startup.

Gemini: dramatic, but never dishonest

Gemini writes the live disaster broadcast (cable-news reports about the storm and about each mayor's choices), the spoken debrief at the end, and the text and artwork of the civic cards players earn.

We set one hard rule early: the AI can be dramatic, but it can never invent a fact. A single made-up casualty number would undermine the whole idea of trustworthy public input. So the engine computes every number first and hands Gemini structured facts through a JSON schema. The server then checks every number in every generated line against those facts, and any line that fails is replaced by a template.

It all has to happen inside a 20-second storm, in two languages, so we ask for the whole script the moment the storm begins and swap lines in as they arrive. Structured output was rock solid, and the image model produced art in our design's exact ink colors in about 10 seconds. The one curveball: a model we started with was retired for new API keys mid-weekend, so every feature now goes through one shared helper that falls back to the next model automatically.

ElevenLabs: the voice of the storm

ElevenLabs gives the game its voice: two news anchors, America News in English and Bharat News in Hindi, plus the narrator and the debrief. Every clip is cached on the server, so a replayed storm costs nothing and still plays if the API is down. The voices are honestly what make people lean in during a demo. Small lessons along the way: Voice Library voices aren't available over the API on the free plan, and Hindi works with Flash v2.5 but not with multilingual v2.

Solana: a public record anyone can check

We didn't want Solana to be "a blockchain integration". We wanted it to answer one question: how can a city trust that public input wasn't quietly changed?

Anyone can verify a play in their own browser: no trust in our server needed.

Every play's decisions are on chain, in plain words. Each game gets a Memo transaction like ready-raleigh:v1:play:raleigh:flood:ABCD:score=75.1:<fingerprint> | Shelter: Underwood School (Five Points); Bus pickup: GoRaleigh stop Peyton St at Brigham Rd; … Anyone can read it in Solana Explorer. No names, just decisions.
Batches are anchored as Merkle roots. Plays are fingerprinted with canonical JSON and SHA-256, and a /verify page lets any browser recompute the fingerprint, walk the proof and read the memo straight from a Solana node, without trusting our server.
Civic signals. When the collected plans reveal something significant, like several different players backing a place the data also ranks highly, the server publishes it on chain.
Soulbound civic cards. Players who trigger a signal, or win an election, earn a Metaplex Core card that can never be sold or transferred. We proved that on devnet: a normal asset transferred, ours was refused.

A soulbound civic card: Gemini paints the art, Solana makes it permanent.

Fitting readable decisions into Solana's limits was a fun puzzle: memos max out at 566 bytes, and a card mint has to fit in a 1,232-byte transaction, where the mint itself takes about 700. Transactions confirmed in seconds for a fraction of a cent.

The same decisions, readable by anyone on Solana Explorer.

Hackathon Experience

We built Mayday Mayor in 24 hours at WolfHacks 2026 at NC State 🐺, for the Center for Geospatial Analytics track: four of us, Adit Shah, Darsh Rank, Sakhi Patel and me, building the cities, the multiplayer, the leaderboard and the blockchain layer in parallel in one repository.

The hardest problem: every city is its own world

The moment we went from one city to four, we learned the real lesson of this project: every new city is a new data problem. Raleigh was built from Census block groups, FEMA flood zones, OpenStreetMap, FEMA's registered shelters and GoRaleigh's transit feed. None of it carried over cleanly. Miami's flood maps include coastal high-hazard zones. San Francisco's danger isn't water at all, it's earthquake liquefaction. New York's is heat. The other cities only had coarser Census tracts, and no shelter or transit data at all.

Each one had to be translated into one engine, and the translation changed the game itself. In Raleigh, about 7% of people are at risk and the best plan scores 75. In Miami, 37% are at risk and the best plan scores 21. Same rules, a completely different city. Some of it we finished, and some is honestly still on our list: New York and San Francisco need their own heat and earthquake models. But it taught us that the hard part of scaling civic tech isn't the code, it's the data, city by city.

Teaching a map who can actually escape

Coloring flood zones is easy. Knowing who can still get out is not. Our first version wildly overstated what a single shelter could do. The breakthrough was treating the city as a road network that breaks as the water rises: a neighborhood that never floods can still be trapped if every road to a hospital goes under. Once we modeled that, the game stopped being a coloring exercise and started showing things a flood map alone never could.

Making trust real

The other thing we kept coming back to was trust. If this is ever going to inform a real city, the AI can't make things up and the public record can't mislead. That pushed us to validate every number the AI writes, to make every decision readable on chain, and to rebuild our civic signals when we noticed the on-chain history could tell half a story.

What I'll remember

The moment the whole loop worked end to end: a room of players planning on their phones, the storm hitting every screen at once, the anchors calling out each candidate by name, and then every decision showing up, in plain words, on Solana Explorer. That's when it stopped feeling like a hackathon project and started feeling like something a city could actually use.

The question we're leaving with is bigger than disasters:

What if cities could rehearse their hardest decisions with millions of residents before they ever have to make them for real?

Thanks to MLH, ACM at NC State 🐺 (Go Pack!), and every sponsor whose tools made this possible.

DEV Community: Aum Pandya