roadgen: The Map Generator We're Building for Proton Bus Simulator

We have been building a map generator for Proton Bus Simulator. It is called roadgen, it runs in a browser, and it does one thing: you give it a street layout, and it hands back a textured 3D city you can drive a bus through. No 3DMAP. No modelling a neighbourhood street by street in Blender.

It is not finished, and there is no release date. This post is the honest state of it — what already works, what still breaks on camera, and where the data actually comes from. Every screenshot here is our own, pulled from the three devlogs on our channel.

Draw a street, get a drivable city

The idea is simple. You mark out where the roads go. roadgen turns that into geometry: carriageway, sidewalks, curbs, lane markings and welded intersections, exported as a 3D file you finish in Blender and load into the game.

This matters because of a lopsided problem in the hobby. There are hundreds of community buses and almost no cities to drive them in. A bus is one object; a map is a whole world, and building one has always meant weeks of manual modelling. That gap is exactly why bus sims have the biggest modding scenes and still run short of maps — the tooling never matched the ambition.

The door has been open for years. MEP opened up map modding back in 2020, which is rare enough for a mobile game. What has been missing since is not permission — it is a way to build a city without modelling every kerb by hand.

Two ways to start a map

You do not have to draw anything if you do not want to. roadgen opens with two buttons: import the real street network, or draw the roads by hand over the map.

Importing pulls the actual road layout of a real place. Drawing by hand is for when you want control — a fictional town, a simplified version of a real one, or a route that only exists in your head. Both paths end at the same generate button.

How a drawing becomes a road network

Streets are layers, not just lines

Every road you add is a layer, and a layer carries two things that matter to a driver: direction (one-way or two-way) and lane count. A lane is 3.5 metres, so a two-way single-lane local street comes out 7 metres wide. Change the lane count and the road physically widens in the output.

Crossing lines become welded junctions

You do not place intersections. You just let two strokes cross, and roadgen welds a junction there when it generates — even when the two roads sit on different layers. Bring a road's endpoint near another road and it resolves into a corner instead.

There is a catch we learned the hard way: the drawing cannot have gaps. A line that looks connected but stops a pixel short is not connected, and the generation will show it. Closing every junction before hitting generate is the difference between a clean run and a broken one.

Smoothing a shaky hand

Hand-drawn roads wobble. There is a normalize setting for exactly that, which averages out the tremor so a street you traced with a mouse comes out straight instead of lumpy. Small feature, but it is the one that makes hand-drawing usable at all.

Where the city actually comes from

This is the part worth getting right, because two different data sources do two different jobs.

OpenStreetMap: streets, buildings and names

The street layout, the building footprints and the names all come from OpenStreetMap. OSM records a building as the outline of a structure with a roof, and those outlines can carry height, floor count and a name. That is why generated buildings land with believable proportions and in the right places — a tall block appears where a tall block exists, and a shop keeps its corner.

AWS Terrain Tiles: the elevation

The terrain is a separate source. Real elevation is an opt-in checkbox, and it reads from Terrain Tiles, an open dataset described as "a global dataset providing bare-earth terrain heights, tiled for easy usage." Leave it off and you get a flat map. Turn it on and the road climbs and drops where the real city does.

A grade profile built for buses

Here is the setting we are proudest of, and it only exists because the map is meant to be driven. When real elevation is on, roadgen computes a vertical grade profile — a curve tuned for buses, with a spline that smooths out undulation.

Raw elevation data is noisy. Dropped straight onto a road it produces a rippled surface that a 15-tonne vehicle bucks over. The grade profile is what turns a noisy height sample into a road a bus can actually hold speed on. It is the one feature in the whole tool that would make no sense if you were only building scenery to look at.

What roadgen generates today

Buildings are procedural and seeded — the lot generator takes a seed number, so the same drawing produces the same city every time. What comes out is a mix: apartment blocks, rendered and bare houses, and commercial frontages with generated names.

The output is a plain OBJ, which is worth noting: it is not locked to Proton Bus Simulator. You import it into Blender, adjust, and export to the game's native format — but nothing stops that same file going somewhere else entirely.

What still breaks

We would rather show this than write around it. These are all from the latest devlog, unfixed.

There is a size limit to respect as well. When we exported a map with full terrain, we had to split it into pieces — a single mesh that large runs into a triangle ceiling on the way into the game. Flat maps stay well clear of it.

How a generated map drives

A generated map does not feel like a hand-built one, and the difference is the terrain. A hand-made map is usually flat because flat is cheap to build. Real elevation means the bus works: it loses speed on the climb and gathers it on the way down, in the same places the real city would make it.

The flip side shows up too. Where the height data is noisy, the road surface comes out uneven, and you feel every ripple through a heavy vehicle. That is not a rendering artefact — it is real geometry, and it is exactly what the grade profile exists to tame.

Want to feel the contrast? Drive the real cities the community already built — the hand-crafted Projeto SP map of São Paulo's Zona Sul is the benchmark we keep measuring against, and it pairs well with any of our Brazilian bus mods.

Generating a district from scratch

The clearest test we have run so far: pick a neighbourhood we had never generated before, draw its streets, and let the tool build it. It threw errors on the first attempt — the first time generating somewhere new always surfaces something — but after fixing those, the district came out clean in Blender, intersections included.

When can you get it?

There is no release date. That is the honest answer, and we would rather give it than invent a month we then miss.

What we can say: the first version will be for PC. A mobile version is not planned yet, because we have not worked out how it would run there. Before any release we want the worst of the bugs above cleaned up — poles out of the road, houses out of the ground.

Every update on roadgen goes to our YouTube channel first — that is where the devlogs are published and where the release will be announced. Subscribe there if you want to know the moment it ships. You can also join our Discord, where the community talks through what it wants the tool to do next. Several features on our list came straight from devlog comments.