Astra Rally
A Three.js rally game · one prompt · 31 min

One prompt. Four stages. Mud on the sills.

Rallyline is a time-trial rally game in a single HTML file. GPT-6.2 Astra wrote it from one art-direction brief, with no follow-up prompts, and this is that first build, unedited. Click the game, then drive.

Click the game to drive. Esc pauses, M turns the sound on. On a phone, turn it sideways for the touch controls.

On its own
The series

Four surfaces, four kinds of grip

Each stage has its own road texture, scenery and handling. Pick one to load it in the game above. Best times stay in this browser.

About

One prompt, 31 min

This game came out of a single conversation with GPT-6.2 Astra in Codex, at extra-high reasoning effort. The prompt asked for a simple Three.js game in one HTML file, followed by a 652-word art brief. It attached no reference images and sent no follow-up prompts.

The brief asked for mid-2000s arcade rally realism: production cars turned into race cars, roads you can read at speed, and scenery built from a few big shapes. Its central rule was this:

“Make the world believable, then exaggerate the details a driver would care about.”

The model planned four stages, each with its own surface, grip and scenery, and wrote the game as a series of patches to one file. It pulled in free assets: Three.js r160, the Barlow Condensed typeface, and CC0 sky photos and scanned textures from Poly Haven (mud, bark, rock, ferns and shrubs). It compressed them and embedded everything in the file, so the game runs offline.

It then tested its own work in a headless browser: an offline load, a full timed run, a saved best time and touch steering with throttle at the same time. It looked at its own screenshots 9 times and reworked the snow cliff, the desert spires and the pine trees from what it saw.

Later conversations went on to rework the physics and the handbrake. None of that is here. The original file was edited in place afterwards, so for this page it was rebuilt by replaying the thread's own patches against the same downloaded assets. The result matches what the next session read from the original, line for line.

Read the full prompt
create a simple game using https://threejs.org/. I want just a single html use this art direction for the game: **mid-2000s arcade rally realism**. The cars and landscapes are recognizable and fairly naturalistic, but the image is designed around what matters at speed: the silhouette of the car, the texture of the ground, and the shape of the next turn. The central art-direction rule is **make the world believable, then exaggerate the details a driver would care about.** **The road is the most expressive part of the picture.** Look at the jungle shot: the mud isn’t uniformly brown or uniformly glossy. Most of the road is a broad, matte clay surface, but the wheel ruts catch the sky in long, almost white streaks. You can see the bend just by following those reflections. The snow scene uses the opposite contrast: dark, churned tracks cut through the pale surface. The desert is flatter and dustier, while the alpine asphalt gets its definition from clean painted lines and a sweeping guardrail. For a game with this feel, give every surface a distinct visual signature that reads from the chase camera. **The player should be able to tell what the tires are about to hit before they get there.** **The cars look like production cars turned into race cars, not exotic showpieces.** Their identity comes from big, legible shapes: a compact hatch or sedan body, a prominent rear wing, dark rear glass, distinct taillights, blue or white paint, sponsor lettering, and a roof number. The best detail is the contrast between the car’s upper and lower halves. In the jungle shot, the bright roof and wing are still clearly defined, while thick, irregular mud nearly swallows the bumper, wheel arches, and sills. That makes the car feel like it has *driven through* the environment rather than been placed on top of it. Start with a car that reads cleanly at a distance, then let the course leave evidence on it. **The scenery works in large shapes first, texture second.** The desert has two red rock spires against open sky. The alpine road has dark ranks of conifers framing a bright mountain. The snow course pairs an immense rock wall on one side with open space on the other. The jungle is much denser, but the palms form a dark frame around a comparatively simple ribbon of road. Up close, the surfaces have mottling, grit, leaves, and scratches; from a distance, there are only a few shapes competing for attention. That is a better target than simply making everything low-poly or covering everything in noise. **Color and lighting belong to the location.** The desert is sand, rust, and dusty blue; the jungle is deep green, warm clay, and flashes of reflected sky; the snow course is slate, dirty white, and a little pink near the horizon. There isn’t one heavy color grade forcing all four places to match. What unifies them is how light separates materials: a bright, broad highlight on a roof, near-black rear glass, broken glints on wet mud, almost no sheen on dry sand. Preserve those differences rather than making the whole frame equally glossy, hazy, or desaturated. **The camera and HUD supply the arcade energy.** The chase view sits close enough for the rear of the car to have weight, but high enough to see past the roof and plan the turn. In the jungle image, the car is angled across the foreground while the road opens to the right; that single composition communicates a slide without needing speed lines or heavy blur. The HUD is much less restrained than the world: oversized italic white numerals, dark outlines, warm red and amber labels, a simple route outline, and a big gear number inside an analog-style tachometer. It feels like televised motorsport crossed with an arcade cabinet. The dense hardware statistics in the snow image are a capture overlay, not part of that design.

The conversation

Prompts typed652 words, no images
1
Prompt to finished game
31 min
Model calls
58
Tool calls37 shell, 9 screenshot views, 7 terminal polls, 4 plan updates
57

Tokens

Written by the model10,575 of them reasoning, never shown
52,060
Input read from cachethe whole conversation is sent again on every call
5.89M
Fresh, uncached input
142,678
Largest single request
132K

Cost at API list price

Output at $40 per million
$2.08
Cached input at $0.40 per million
$2.36
Fresh input at $8 per million
$1.14
Estimated total
$5.58

What came out

Stages
4
The gameone HTML file, with Three.js, the font and the textures inside
2.3 MB
Model
GPT-6.2 Astra

Counted from the Codex session transcript of that one conversation, which ended 18 November 2026 at 01:44 UTC. Building and publishing this page is not included. The cost is an estimate at the Standard-tier API prices published for GPT-6.2 Astra; a ChatGPT subscription bills differently.