Free City Builder & Traffic Game Assets (Blender, Unreal, Unity, Godot)

# Free City Builder & Traffic Game Assets (Blender, Unreal, Unity, Godot, Three.js)

Part of the Index Scout "Game-making assets" series: free sources organized by genre, downloaded and checked on our own machine. This entry covers city builders, tycoon and SimCity-style games, traffic and driving sandboxes, and isometric town maps.

## When to use
Use when an agent or developer needs free, commercial-safe 3D buildings, road tiles, street props and vehicles, plus a tested road autotiling and zoning helper so roads connect correctly as the player draws them.

## Tested packs (all CC0, downloaded and checked 2026-10-21)
| Pack | What's inside (counted) | Link |
|---|---|---|
| Kenney City Kit (Commercial) | 41 models (GLB, FBX, OBJ each): 14 shops and offices, 5 skyscrapers, 16 low-detail versions for distant blocks, awnings, overhangs and parasols | [kenney.nl/assets/city-kit-commercial](https://kenney.nl/assets/city-kit-commercial) |
| Kenney City Kit (Suburban) | 40 models: 21 house types (building-type-a to u), fences, driveways, paths, planters and two tree sizes | [kenney.nl/assets/city-kit-suburban](https://kenney.nl/assets/city-kit-suburban) |
| Kenney City Kit (Roads) | 95 models: straight, end, bend, curve, T-intersection, crossroad, roundabout, slopes, bridge, driveways, plus barrier and sidewalk variants, traffic lights, street lights, road signs, power poles and construction props | [kenney.nl/assets/city-kit-roads](https://kenney.nl/assets/city-kit-roads) |
| Kenney City Kit (Industrial) | 37 models: 20 factory buildings, chimneys, water tower, tanks, shipping containers, solar panels and wind turbines | [kenney.nl/assets/city-kit-industrial](https://kenney.nl/assets/city-kit-industrial) |
| Kenney Car Kit | 50 models: sedan, SUV, taxi, police, ambulance, firetruck, garbage truck, delivery van, truck, tractor, race cars and karts, separate wheels, and crash debris (doors, bumpers, tires) | [kenney.nl/assets/car-kit](https://kenney.nl/assets/car-kit) |

Checks we ran: all 263 GLBs have a valid glTF 2.0 header with a length matching the file and parseable JSON; all 305 preview PNGs have a valid PNG signature; every download has a License.txt stating CC0. Road tiles measure exactly 1 x 1 units centered on the origin (about 0.02 tall), so a 1-unit grid lines up with no scaling. Suburban houses are about 1.3 x 1.0, commercial buildings about 0.9 x 0.9 and industrial buildings up to about 2.1 x 1.2, so some industrial pieces span two cells. A sedan is about 1.5 x 2.5 units, so scale cars by about 0.3 to fit a road lane.

## Road autotiling, zoning and growth helper (tested)
`roadTile` turns a 4-neighbor mask into the right City Kit Roads piece and a number of 90 degree turns. `City` stores a grid of roads and zones, returns road meshes to place, grows residential, commercial and industrial zones only when they touch a road (residential is capped by jobs), and saves or loads JSON. Tested in Node 20 with assertions covering all 15 road masks, an end, straight, T and crossroad layout, growth rules and save/load.

```js
// City grid: road autotiling (Kenney City Kit Roads names), zoning and simple growth.
const N = 1, E = 2, S = 4, W = 8;
// mask -> [piece, quarter turns clockwise from the piece's base orientation]
const BASE = { end: S, straight: N | S, bend: S | E, intersection: E | S | W, crossroad: 15 };
const PIECE = { end: 'road-end', straight: 'road-straight', bend: 'road-bend',
  intersection: 'road-intersection', crossroad: 'road-crossroad' };
const rot = m => ((m << 1) | (m >> 3)) & 15; // rotate mask 90° clockwise
export function roadTile(mask, rotOffset = 0) {
  if (mask === 0) return { model: 'road-square', turns: 0 };
  for (const [k, base] of Object.entries(BASE)) {
    let m = base;
    for (let t = 0; t < 4; t++, m = rot(m)) if (m === mask) return { model: PIECE[k], turns: (t + rotOffset) % 4 };
  }
}
export class City {
  constructor(w, h) { this.w = w; this.h = h; this.cell = Array.from({ length: w * h }, () => ({ t: 'empty', lvl: 0 })); }
  at(x, z) { return x >= 0 && z >= 0 && x < this.w && z < this.h ? this.cell[z * this.w + x] : null; }
  set(x, z, t) { const c = this.at(x, z); if (!c || (t !== 'empty' && c.t !== 'empty')) return false; Object.assign(c, { t, lvl: 0 }); return true; }
  isRoad(x, z) { return this.at(x, z)?.t === 'road'; }
  mask(x, z) { return (this.isRoad(x, z - 1) ? N : 0) | (this.isRoad(x + 1, z) ? E : 0) | (this.isRoad(x, z + 1) ? S : 0) | (this.isRoad(x - 1, z) ? W : 0); }
  roadMeshes(rotOffset = 0) { const out = []; for (let z = 0; z < this.h; z++) for (let x = 0; x < this.w; x++)
    if (this.isRoad(x, z)) out.push({ x, z, ...roadTile(this.mask(x, z), rotOffset) }); return out; }
  // Zones grow one level per tick only when next to a road; residential needs jobs nearby.
  tick() { const jobs = this.cell.filter(c => c.t !== 'res' && c.t !== 'road' && c.lvl > 0).length * 4 + 4;
    const pop = () => this.cell.filter(c => c.t === 'res').reduce((s, c) => s + c.lvl * 3, 0);
    for (let z = 0; z < this.h; z++) for (let x = 0; x < this.w; x++) { const c = this.at(x, z);
      if (!['res', 'com', 'ind'].includes(c.t) || c.lvl >= 3 || !this.mask(x, z)) continue;
      if (c.t === 'res' && pop() >= jobs) continue; c.lvl++; }
    return { pop: pop(), jobs }; }
  save() { return JSON.stringify({ w: this.w, h: this.h, cell: this.cell }); }
  static load(s) { const d = JSON.parse(s), c = new City(d.w, d.h); c.cell = d.cell; return c; }
}
// Building model for a zone and level (Kenney City Kit names).
export const buildingFor = (t, lvl, i = 0) => lvl === 0 ? null : {
  res: ['building-type-a', 'building-type-f', 'building-type-m'], com: ['building-a', 'building-g', 'building-skyscraper-a'],
  ind: ['building-a', 'building-h', 'chimney-large'] }[t][Math.min(lvl, 3) - 1];
```

Quick start:

```js
import { City, buildingFor } from './city.mjs';
const city = new City(32, 32);
for (let x = 0; x < 32; x++) city.set(x, 10, 'road');
city.set(5, 9, 'res'); city.set(6, 9, 'com');
city.tick();                        // { pop, jobs }
city.roadMeshes();                  // [{ x, z, model: 'road-straight', turns: 1 }, ...]
buildingFor('res', city.at(5, 9).lvl); // 'building-type-a'
```

## Hooking it up
- Three.js: load the GLBs with `GLTFLoader`, put each road tile at `(x + 0.5, 0, z + 0.5)` and set `mesh.rotation.y = -turns * Math.PI / 2`. Our mask convention assumes `road-end` opens south and `road-bend` joins south and east. If your first render shows bends facing the wrong way, pass `rotOffset` (1, 2 or 3) to `roadMeshes` once; it's a one-time calibration for your engine's axes.
- Use the `low-detail-building-*` models from the Commercial kit for far-away blocks to save draw calls, and swap in the detailed ones near the camera.
- Godot, Unity, Unreal: import the GLB folder (each kit ships FBX and OBJ too); the helper is plain math and easy to port.
- Traffic: drive Car Kit vehicles along the centers of road cells from `roadMeshes()`, and use the separate wheel models if you want them to spin.

## Tips
- Need menus and money counters? See the series entry [Free Game UI, HUD Icons & Fonts](https://promoteindex.com/skills/free-game-ui-hud-icons-fonts-controller-button-p).
- Driving-focused game? Pair this with [Free Racing Game Assets](https://promoteindex.com/skills/free-racing-game-assets-blender-unreal-unity-god).
- Make the GLBs lighter for the web with [Optimize glTF for Web Games](https://promoteindex.com/skills/optimize-gltf-for-web-games-with-gltf-transform-).
- Keep a `CREDITS.md` even though CC0 doesn't require it: "Kenney (kenney.nl)".

## Attribution
Assets by [Kenney](https://kenney.nl), CC0 1.0 per the License.txt inside each download ([license text](https://creativecommons.org/publicdomain/zero/1.0/)). Counts, measurements and checks by Index Scout on 2026-10-21; the helper code is original and released CC0. Always re-check the license file in the copy you download.