Steven Chen's Website
HomeBlogProjectsPublicationsCV
Back to list

What If a City Builder Were Open Source and Ran in the Cloud?

#games#business

In the last post I argued that Cities: Skylines II's traffic is broken at the routing level, and that the fixes are textbook. The obvious follow-up: if it's that fixable, who builds the better one, and how do they get paid?

Here's a model I think could work: the game is fully open source, and the money comes from the cloud.

Why open-source games are rare

Linux and Python thrive because they're infrastructure. Companies depend on them, so companies pay engineers to maintain them. A city builder is a consumer product; no business breaks if it disappears, so nobody funds it. Games also need one coherent design vision, which is hard to crowdsource, and art is expensive.

The exceptions are instructive. OpenTTD lives on by re-implementing a classic whose design was already finished. Mindustry keeps its code on GitHub and is pay-what-you-want on itch.io, yet people still buy it on Steam for convenience and to support the developer. Giving the code away didn't stop people from paying.

The model: give away the code, sell the compute

The game is AGPL. Anyone can build it, run it, share binaries, or host their own server. I'm not trying to stop redistribution. Aseprite famously moved from GPL to a no-redistribution license in 2016 for exactly that reason; I'd rather accept it and charge for something you can't copy.

Why AGPL and not plain GPL: GPL only applies when you hand out binaries. A competitor who modifies the code and only runs it on their own servers never has to share anything. AGPL closes that gap, which matters when hosting is the whole business. Contributors sign a CLA, so the copyright stays in one place and the project can still dual-license later.

That something is compute. City builders happen to be one of the best-suited genres for it:

  • They tolerate latency. A 100 ms delay ruins a shooter. Nobody notices it while dragging a road.
  • Late game is CPU-bound. A big city melts a laptop. The players most willing to pay are exactly the ones whose hardware gives up.
  • Single-player cities don't need full simulation while you're away. Unlike a persistent MMO world, a city's citizens can be frozen to disk when you log off, and many cities can share one server.
Architecture: an official cloud runs the simulation and serves three tiers of players

Three tiers, each paying for something real: cheap cloud simulation for mid-range PCs, simulation plus streamed rendering for old laptops and phones, and enormous cities for high-end machines whose CPUs, not GPUs, are the bottleneck. It's the old free-to-play deal minus the loot boxes: the players who pay for the cloud fund the game for everyone who plays it locally for free, and they pay for service, not for unlocking things that were cut out of the game.

What to tie to the server, and what not to

Vercel keeps Next.js open while tying some of its best features to its own hosting. Games can't copy that blindly. If you strip a feature that could run locally and lock it behind your cloud, someone forks the code and adds it back. That's what happened when Redis changed its license in 2024: the community forked it into Valkey, backed by the big cloud providers, and a year later Redis added an open-source license back.

So only tie features that genuinely need a shared server:

  • A global market where every player's city trades with every other.
  • A stock exchange where companies from thousands of cities are listed together and trade against each other.
  • Cities too large for any desktop CPU.

Anyone can run the code. Nobody can fork the other hundred thousand players.

That raises an obvious question: if your city sleeps when you log off, how does it keep trading? It doesn't need the full simulation for that. While you're away, the cloud swaps the per-citizen model for a cheap statistical one that extrapolates your city's output and demand from its last session and keeps offering them to the market. Your companies keep trading and their share prices keep moving, at a tiny fraction of the cost of simulating every citizen. When you log back in, the full simulation resumes from wherever the market left you.

The graveyard

This has been tried, badly.

SimCity (2013) required an always-on connection, claimed parts of the simulation ran in the cloud, and launched with servers so broken the game was unplayable. Someone soon hacked it to run offline, and Maxis eventually shipped an offline mode. Being online wasn't what killed it. Forcing it, overselling what the cloud did, and launching on servers that couldn't cope did. If a city builder goes online, it has to be optional, honest about what runs where, and stable on day one.

SpatialOS, Improbable's platform for running game simulations in the cloud, saw several of its flagship games shut down or cancelled in 2019. Cloud-scale simulation is hard to make pay.

The hard parts

I'm not pretending this is solved:

  • Unit economics. CPU simulation is cheap per hour; streaming GPU rendering is not. The pricing has to survive a player who logs 50 hours a month.
  • Consumers aren't companies. Vercel's customers are businesses that pay without blinking. Gamers hate subscriptions.
  • The AWS problem. Open server code means a competitor can host it cheaper. AGPL forces them to publish their changes, but it doesn't stop them. The real defense is the network effect above, not a license.
  • Absent players. An extrapolated city can't react when the market it trades in crashes. The statistical model needs limits, so nobody logs back in to find their city ruined, or made rich, by events they had no chance to respond to.
  • Surviving to launch. Revenue only arrives once the game is good, and that takes years.

The business model is the easy part. The hard part is still the one from the last post: build a simulation where traffic actually behaves like traffic. Get that right, and the rest has something to stand on.

References