The first system worth showing off is how roads are put together. In Regions, a road is not a single object it is a bundle of parallel zones, and every zone has a type that tells the simulation what it is for.
The current type list: drive lanes, bus lanes, tram tracks, bike lanes, parking strips, sidewalks, shoulders, medians, and a shared type for streets where everyone mixes. Each type carries a few properties:
- Drivability — whether vehicles may enter it at all. A median is part of the road, but nothing should ever drive across it.
- Lane tags — a bitmask that filters which vehicles may use a drivable lane. A bus lane is drivable, but only for buses. Same trick for trams and bikes.
- A default width — so drawing a road gives you sensible proportions out of the box.
The defaults we have landed on so far, for the types that have one:
| Zone type | Drivable | Default width |
|---|---|---|
| Bus lane | ✓ (bus tag) | 3.3 m |
| Bike lane | ✓ (bike tag) | 1.5 m |
| Parking | — | 2.4 m |
| Sidewalk | — | 2.0 m |
| Shoulder | — | 1.2 m |
| Median | — | 0.8 m |
Drive lanes, tram tracks, and shared streets take their width from the road that contains them.
Every type also gets its own debug color, so a road viewed in the editor reads like a transit map: blue for traffic, red for tram, green for bikes and sidewalks, grey for parking. It sounds like a small thing, but being able to see the lane structure at a glance has already caught more authoring mistakes than any validation code we have written.
The road tool
Roads are drawn in-game, with a tool that grew out of playing every city builder’s road tool and keeping a grudge list. You click to place, and the road exists immediately as real geometry the surface is generated on the spot (a procedural ribbon first, then dressed with proper street meshes that deform along the curve), the terrain flattens itself under the corridor, and lane markings are painted on without anyone hand-decorating anything.
The opinionated part is how much you can change after a road exists, without redrawing it:
- Lanes are live. Retype any lane — drive, bus, bike, and onward through the list add or remove lanes, and resize a lane’s width in place. A four-lane arterial becomes a two-lane street with bus lanes and a bike track in a few moves.
- Turn bays. A dedicated turn bay drops onto a junction on demand, instead of forcing you to widen the whole road for one busy left turn.
- Speed limits live on the road. Every road shows its limit and can have it changed on the spot, badges and all.
- Demolition is honest. Remove a single segment or clear a whole area at once, and orphaned nodes clean themselves up instead of littering the map with stubs.
Junctions you can sculpt
Junctions get the same treatment. Any junction can run on a signal or on signs, and each approach can be set to stop, yield, or free down to per-lane signs, if you want a slip lane that never has to stop. The geometry is workable too: approaches can be shifted, rotated, or the junction mouth resized, and the lane graph rebuilds around whatever you sculpt.
And when the automatic lane connections guess wrong they usually don’t, but “usually” is doing real work in that sentence you can wire arriving lanes to departing lanes by hand. It is the kind of feature nobody notices until they need it, at which point it is the only feature that matters.
Roundabouts
Roundabouts went in early, because nothing stress-tests a road network like a ring where everyone is merging at once. They are first-class pieces in the build tool: the ring’s lane count is adjustable, and markers on the ring let you override how an entry joins it when the defaults guess wrong.
The interesting part is that a roundabout has no signals and no controller. When the road network bakes, each entry gets a list of its foes the ring arcs it must give way to and that yield map is what everything downstream reads from. Which brings us to…
Things that broke
A devlog isn’t complete without a broken-things section, so here are four, straight from the pile:
The junction that exploded. Two road surfaces meet at a junction by getting stitched into a shared cap, which means finding the right corner points at the right angle. For one specific range of angles, that math picked points on the wrong side of the road entirely, and instead of a clean corner the junction erupted into a spiky burst — like the intersection had taken a firework to the face.
Connections wired to the wrong lane. Lane connections through a junction are assigned automatically by matching arriving lanes to the nearest departing one. On a tight junction, “nearest” occasionally meant a lane on the wrong side of the road an arriving lane paired with a departing lane pointed back the way it came. The debug overlay made it obvious once we knew to look: guide rails crossing to the wrong side instead of running parallel.
A roundabout with a seam. The ring is built by sweeping a cross-section around a circle and welding each entry’s surface into it at the correct point on that circle. Get the arc position for one entry off by even a little, and the weld fails silently the surfaces just don’t quite meet, leaving a visible notch where a road enters the ring.
A road that can’t hold its width. Lane boundaries are interpolated along the road’s curve, and for one stretch that interpolation ran in the wrong space so the boundary drifted independently of the centerline instead of tracking it. The road visibly narrows, widens, and wanders, like it was drawn by someone who lost interest halfway through.
There is more in the road system we are not showing yet a couple of features deserve their own entry, and one is not allowed on camera until it stops embarrassing us. Next up: how vehicles actually navigate this network we just spent an entire post building.