Game DesignProduct DesignMobile FirstDesign Systems

Linesmith: Designing a Game Around Induced Demand

A transit puzzle game where every road you build brings more cars.

Role
Solo designer and developer
Team
Me, building with Claude Code
Timeline
18 days to closed beta
Platform
Browser, phone first

10

Cities, traced from OpenStreetMap

60+

Releases so far, each with a changelog entry

40+

Browser test suites, phone and desktop layouts included

Context & Background

Linesmith is my second browser game. The first one, Roundabout, peaked at 466 people playing at once. When I looked at who those players were, 70% of them were on a phone. So the next game would start on a phone.

I live in Kuala Lumpur and sit in its traffic like everyone else. Planners have a name for why new roads rarely help: induced demand. Build a road and people who used to stay home or take the train start driving on it, until it jams again. It's well known in transport circles and almost unknown outside them. I wanted a game where you work this out by playing, without anyone telling you.

The Problem

Turning a planning idea into a game

Most people believe more roads mean less traffic. If the game simply said otherwise, nobody would care. Players had to build the road themselves, watch it fill up, and go looking for something better.

City simulations also tend to grow. Traffic lights, bus lanes, zoning and car ownership all exist in real cities, and each one is another rule to learn before you see the point. On a screen the size of your hand, with buses, trains and cars all moving at once, there's room for little else.

And I was building it alone. Anything I added, I'd have to balance, test and explain myself, so scope decided more of the design than anything else.

My Role

Game design

The rules, the economy, pacing and how you lose

Visual and UI design

Art direction, the map style, the interface and its style guide

Writing

A voice guide, and every word a player reads

Research

Transit costs and commute data, transit maps, and my notes from Roundabout

Build and release

Directed the build with Claude Code and shipped every release

Discovery and Research

Starting from how transit actually works

Before writing any rules, I read up on what transit costs, how much it carries, and how people choose between a bus and their car. The game simplifies a lot, but the proportions come from there. A metro line costs far more than a bus route and carries far more people, and it never gets stuck in traffic. Commuters compare the trip by transit with the trip by car, and in the game they do the same. The day follows a real commute too, with a rush to work, a quiet middle and a rush home, so the quiet hours are when you build.

I also went back through my notes from Roundabout. Design at 390px first. Never move the camera while a finger is on the screen. When something can't be done, show where and why, because “nothing happened” was the most common complaint I got last time. And keep the rules in a simulation that runs without any graphics, so it can be tested on its own.

The Solution

One rule on real cities

You plan transit for a city. Homes send people to offices and shops, and you drag a finger across the map to draw bus and metro lines that get them there before they lose patience.

Buses are cheap. They also share the road with cars, and drawing a bus line lays road wherever it goes. Every new road gives nearby homes a way to drive, and anyone your transit serves badly will take it. Metro costs much more, runs on its own elevated track and never jams. If too many people end up waiting at a stop or a house, the run is over. If you serve the city well, it grows around your lines.

Nobody in the game tells you that roads make traffic worse. Most players draw a few bus lines, watch the cars pile up behind their buses, and start saving for a metro.

Riders wait under a sign for where they're headed: an office pictogram, a shopping bag or a house

The Design Challenge

Too busy to read on a phone

A friend and I played a lot of runs on our phones, and we both got stuck in the same place. Early on the game looked calm. Late in a run it looked like chaos, and on a small screen you couldn't tell which part of the city needed you.

A late-game city should feel busy, so emptying the screen wasn't the answer. I wanted it busy and organised at the same time. I studied how other transit games keep a big network readable, and how real transit maps manage it with hundreds of stations. Transit maps get away with a lot. Lines only run straight or at 45 degrees, and the geography is simplified until it barely matches the street map, yet people find their way. I took that approach for the whole map. Rivers, coasts and parks follow the same angles as the roads, every corner has the same radius, and outlines are simplified until only the shape that matters is left. Against that quiet ground, the lines are the loudest thing on screen. Cars are all one warm grey so they never compete with a line's colour, and no more than three queue at a kerb.

Then I went through the interface. I captured every screen at phone and desktop sizes and wrote down 15 things that could be removed, merged or shown only when needed. I built 8 of them and kept the reasons for skipping the other 7. Weather is one example. It used to announce itself in a full sentence every time; now the sentence shows once, and after that the sky and a small clock icon tell you. Money stayed on screen, because the economy needs it in sight.

I also kept a written list of what the game would not have. Traffic lights, zoning and car ownership are on it. Bus lanes made it into the code before I took them out of the interface, because they made roads better, which undercut the whole idea.

The art target I started from. I liked the colours. There was far too much going on for a phone
A late-game Budapest at night. Flat ground and simple blocks, with the lines on top

Real Cities

Ten cities, traced

Every city's rivers, coasts and parks are traced from OpenStreetMap. Budapest has the Danube and its islands, Istanbul has the Bosphorus. Water changes how you play: a bus line needs a bridge to cross it, and a metro goes straight over.

Each city also has its own weather, at the hours it really happens. Kuala Lumpur gets afternoon storms, Dhaka gets the monsoon, Budapest gets snow in the morning and Cairo gets sandstorms. While it lasts the roads slow down, and the metro keeps running on time.

Top: Budapest, Kuala Lumpur, Istanbul, London, Cairo. Bottom: Hong Kong, Dhaka, Paris, Seoul, Bangkok
A storm in Kuala Lumpur, snow in Budapest, a sandstorm in Cairo, and Seoul

The Interface

A small design system for a small screen

I wrote the interface rules down early, so a new screen would match the old ones without a redesign. Teal is the only accent, and it's used for the main action or a selected option. All the other colours belong to the map. Anything that sits over the city is the same frosted glass, in a day and a night version, so the city always shows through.

There are three kinds of button, and you pick one by what it does. The main action sits at the bottom where your thumb is. Nothing you can tap is smaller than 44px. Icons are drawn as 24px line icons with a 2px stroke, and a new one gets drawn to match instead of coming from an icon set.

The words follow a voice guide. Hints stay short, there are no exclamation marks anywhere, and each idea has one word for it. I audited every line in the game against it.

The design system: colour, type, spacing, buttons, icons and voice
The same glass over a live city, by day and by night

Performance

Keeping phones cool

Games in a phone browser have a habit of making the phone warm, and a game you play on a coffee break shouldn't eat your battery. I measured where each frame's time went on a phone-sized screen and cut the work nobody would notice missing.

Most of the savings came from drawing less often. Phones with 90 or 120Hz screens were drawing the city up to twice as often as a 60Hz phone, with nothing to show for it, so the game now stops at 60 frames a second. When nobody is touching the screen and the camera is still, it drops to 30. The city moves slowly enough that it looks the same, and the phone does half the work. Behind a menu, where the city is blurred under glass anyway, it runs at 15. The game also pauses when you switch apps, and only keeps the screen awake while a run is actually playing.

The rest came from not redrawing things that hadn't changed. Buildings, trees, stop signs and rider counts are drawn once and only redrawn when they change. A train carriage is painted once for each direction it can face, where it used to be rebuilt every frame.

Feedback reports from the game include the frame rate and the graphics chip, so when someone says it's slow I can see why. With these changes in, phones no longer warm up during a run.

Pacing

When the middle of a run went quiet

There was a second problem, the opposite of the busy late game. Once a network was in place, a run went quiet and there wasn't much left to decide. Since the rules run without graphics, I could check this with scripted players on many maps instead of trusting my own feel for it. They confirmed it: a player doing very little did about as well as one doing everything.

I fixed it by limiting what you can build. Money stopped being the limit. Everything now comes from the Depot, a shop with a small stock that restocks through the day, so each thing you buy is a choice about what the city needs next. I retuned the pacing around it so a growing city keeps asking for something new.

Seoul, growing around its lines

Outcomes

Closed beta in 18 days

Linesmith opened as a closed beta at playlinesmith.com 18 days after the first commit. It now has 10 cities, cloud saves and a leaderboard for each city, and it has had more than 60 releases. Every release gets a changelog entry written for players. Feedback comes straight to me from a button in the game.

Automated browser tests check the phone and desktop layouts, saves and the beta sign-in. Next up are a Steam page and a downloadable desktop build.

Reflection

The best decision was keeping the rules separate from the graphics. It meant I could test pacing with numbers, which settled arguments I would otherwise have had with myself for days.

I'd change how I handled touch. Testers told me drawing a line felt stiffer than drawing a road in Roundabout. Lines hold to long straight runs, which keeps a network tidy, and I tuned that by how the result looked before I'd spent enough time with it under a thumb. Next time I'd test the feel on real phones first.

Most of the work that mattered was taking things out. Each system I cut made the main idea easier to see, and the list of things the game would not have saved me more time than any feature.

How this was built

I built Linesmith with Claude Code. I set the direction, wrote the rules and the style and voice guides, and reviewed each change before it shipped. It runs on TypeScript and PixiJS, hosted on Cloudflare Workers.

See it in Action

You can join the closed beta at playlinesmith.com. It runs in any phone or desktop browser, so there's nothing to install.