How the Daily Track Is Generated

The promise of Daily Dirt Rally is that everyone drives the same track on the same day. There is no track database to keep in sync and no download — the layout is recomputed from the calendar date whenever it is needed, and the same date always produces the same track. This guide explains exactly how, because the mechanism is simple enough to be worth understanding and it tells you what shapes to expect before you drive.

Step one: the date becomes a number

The seed of the day’s first track is the date string itself — 2026-09-07 and nothing else. Those characters are folded into a single integer with a classic string hash, and that integer feeds a small deterministic generator that produces the sequence of pseudo-random values every later step consumes. The second and third races of a set are made the same way from the date with the race added, 2026-09-07/race2 and 2026-09-07/race3.

Two properties matter here. It is deterministic: the same date always yields the same number sequence, on any machine, which is what makes a shared daily track possible without storing anything. And it is unpredictable enoughthat consecutive dates produce completely unrelated layouts — yesterday’s circuit tells you nothing about today’s.

Step two: a square grows into a circuit

Every track begins life as the smallest possible loop: a 2×2 square of grid cells, four cells in a ring. That is not a track, it is a starting point.

The generator picks a target length from the date, between 32 and 44 tiles, then runs expansion steps until the loop reaches it. Each step:

1. picks one edge of the current loop at random — two neighbouring cells;
2. picks a perpendicular direction, outward or inward, at random;
3. projects those two cells one step in that direction;
4. checks whether either projected cell already belongs to the loop — and if either does, abandons this step entirely;
5. otherwise splices the two new cells into the loop between the original pair.

Each successful step replaces a straight section with a three-sided detour, so the loop grows a bump and two tiles longer. Repeat that a dozen times or more on a loop that is itself getting longer and more convoluted and you get the interlocking rectilinear circuits you actually drive.

Step three: cells become tiles

The loop at this point is just an ordered list of grid coordinates. To turn it into artwork, the generator walks the list and asks one question per cell: which of my four neighbours are the previous and next cells in the loop?

The answer is packed into a four-bit number — north is 1, east is 2, south is 4, west is 8 — so a cell that connects north and south scores 5, and one that connects north and east scores 3. Sixteen values are possible, and there is one piece of tile art for each. Because the path is a closed loop, every cell has exactly two connections, so in practice you only ever see six of them:

This is why every circuit is built from right angles and long straights rather than sweeping curves: the tiles are square, 360 units on a side, and they only ever meet edge to edge. It is also why the four-tile straight matters so much when you plan nitro use — the geometry comes in fixed units, so you can count them.

Step four: the collision masks

Each tile ships with a 16×16 grid recorded from its own artwork, marking every cell as drivable dirt or solid grass. That grid — not the tile’s square footprint — is what the game tests your truck against, which is why the boundary described in the track limits guide follows the ragged painted edge to within one cell.

Storing the mask alongside the art rather than deriving a hitbox by hand means the two can never drift apart. If a tile is redrawn, its mask is regenerated from the new pixels.

Step five: checkpoints, start line and metadata

The start line goes at the end of the loop’s longest straight, like a real circuit, and the starting grid lines up on that straight: eight trucks, two by two, in four rows. There is one checkpoint besides the line, halfway round the lap measured along the road; a lap counts when you cross the line having passed it, which is enough to make cutting the course pointless without being restrictive.

The server also computes the numbers you see on the front page: checkpoint count, total distance (tiles multiplied by tile size), and a difficulty rating derived from the mix of surfaces on the circuit. That last one is currently not very informative — as explained in the track limits guide, daily tracks are cut entirely as dirt at the moment, so the surface mix is the same every day and the rating does not move. It will start meaning something when varied surfaces reach the daily generator.

What this means for you as a driver

• The track is knowable. It does not change while you practise. Every second you invest in learning today’s braking points pays off for the rest of the day and then resets cleanly at midnight.
• Straights come in whole tiles. Count them on the minimap and plan your boosts around four-tile runs.
• All corners are 90 degrees. There are no decreasing-radius surprises. Once you have a technique for one corner you have a technique for all of them.
• Nobody has a track advantage. Same seed, same layout, same everywhere — the only variables are your line and your nitro discipline.

Trying it yourself

The generator is a few hundred lines of TypeScript with no external dependencies, and the daily layout is served over a plain JSON endpoint, so anyone curious can inspect a day’s track data directly. If you build something interesting with it — a route planner, a lap-time simulator, a visualiser — we would genuinely like to see it. The contact page reaches a real inbox.

Next: how times are recorded and what keeps the leaderboard honest.