A rainy neon night-city street racer that AI agents built in about a day.
This is me playing around with what AI can do, not a product. It's open source and free: look around, run it, take whatever's useful.
- Code: Claude Code (Claude) and Antigravity (Gemini) wrote all the code and shaders, in Unity 6.3 with URP. My job was mostly looking at screenshots and saying yes or no.
- Art: the city and the cars are free, licensed assets (Unity's Megacity Metro sample, BlenderKit, Poly Haven, ambientCG, Kenney) that the agents found, placed, relit and wired up. The facade details, the cockpit and the street lamps are built by Blender scripts. The steering wheel was generated: a concept image from Google Flow, turned into 3D by Tripo, then reduced in Blender.
- Checks: every visual change was measured from screenshots, not eyeballed.
- Sound: the engines are synthesised live, with no recorded samples.
Only tested on macOS with Apple Silicon (M3 Max). Other platforms may work, but haven't been tried.
- Install Unity 6000.3.26f1 with Unity Hub.
scripts/build.shexpects it at/Applications/Unity/Hub/Editor/6000.3.26f1. - Clone the repo. It's about 1 GB, because the city art is included.
- Run
./scripts/build.shto buildBuilds/NeonRedline.app, then./scripts/play.shto play. Or open the project in Unity and press Play inAssets/Scenes/Main.unity.
W / S to drive, A / D to steer, C to change camera; the full list is under Controls.
docs/argon-*/: the work packs. Claude wrote each pack (what to change and how to check it), Antigravity implemented it, and Claude reviewed the result against screenshots and measurements. Claude implemented some packs itself.docs/asset-pipeline.md: how detailed parts are made from a concept image.docs/showcase/: how the teaser was shot in the game and cut.provenance/ledger.jsonl: every asset file and where it came from; for AI-made ones, the tool, model and prompt.
This was my first end-to-end game with agents.
- Plan the whole game up front.
- Split the work across subagents: physics, assets, lighting, UI.
- One subagent per asset, all in parallel, instead of one agent queuing through every part of a car.
- Those assets feed a lead 3D-design team that builds the scenes.
- A conductor agent puts the game together.
- Give the agent a browser from day one, so it drives the tools itself.
- Run it AFK. All I really needed to do was approve images, videos, animations and how the physics felt, and the agent can show all of that in the chat on my phone.
- Code: MIT, see LICENSE.
- Assets keep their own licences. Every one is listed in CREDITS.md and
Assets/Manifest/manifest.json. The Megacity Metro art is under the Unity Companion License, which allows its use only with Unity. - Some of the free car models are modelled on real cars. The names in the game are made up, and no car maker is involved in or endorses this project.
A first-person cyberpunk street racer in Unity 6.3 (6000.3.26f1, Apple Silicon) with the Universal Render Pipeline. It's 3 a.m. in a rain-soaked megacity: you drive a hybrid V10 hypercar around a 3.6 km circuit through six districts, against three rivals or your own best-lap ghost.
The whole scene is assembled at runtime by NeonSceneBootstrapper from assets under Assets/Resources.
Rendering
- Wet asphalt (
WetRoadPBR): PBR lit by every light through URP's Forward+ cluster loop, painted lane markings, puddles in the gutters and wheel ruts, rain ripples, and screen-space reflections traced against the previous frame (NeonRenderFeature). - Volumetric light: the nearest 32 lights (street lamps, neon spill, headlights) scatter through the rainy air, at half resolution, over a blue haze that stays clear near the camera and fills the depth of the street.
- Overcast night sky glowing blue with city light, brighter than the unlit walls so towers read as dark shapes against it, with a cloud deck lit from below and a distant procedural skyline; the distance fog matches its horizon colour.
- A 40-light pool: downward street-lamp spots, coloured neon spill, tunnel ceiling lights; the lights nearest the car cast soft shadows. A realtime reflection probe follows the camera.
- Lit rain streaks that sparkle near lights, ACES with HDR grading, wide bloom, anamorphic lens-flare streaks, motion blur, film grain.
- STP temporal upscaling: native at 1080p, 85 % around 1440p, 67 % at 4K (
NeonRenderScale).
City
- Towers, storefronts, rooftop clutter, neon text signs, LCD billboards, skybridges, hover cars and airships from Unity's Megacity Metro sample, placed along the track by
MegacityDistrictBuilder(street-front row plus a taller background ring, with road-clearance and overlap checks). - Towers are re-lit for night by
NightTower: Megacity's facade profiles; four facade types picked per tower by its height (glass towers as curtain walls: flush floor-to-ceiling glass between thin mullions, no ledges; offices with ribbon windows, cheap apartments with low floors and small warm windows, older mixed blocks in between), each with its own floor height, window size, lit share and room light colour; matte dark concrete that differs from building to building and darkens towards the top, soot and stains, windows set 45 cm into the wall (the view ray is traced into the opening, so the jambs, the shadowed head and the sill show at an angle), interior-mapped rooms with a lit share that varies by building, and neon signs tinting the walls next to them. Rooftop machinery is hidden so roof outlines stay clean against the sky. The far skyline towers (MegabuildingFacade) get their own pattern, brightness and sparse lit windows each. - Roadside barriers 1.75 m tall: a concrete kerb, a wall of metal panels, concrete uprights with a cyan light slot every 6 m and a thin light line under the cap (
TrackSpline.BuildBarrierAndViaductMesh). - The Bore tunnel (
TunnelShell): damp concrete, LED strips along both ceiling corners and ceiling panels every 6 m. - Street-front towers get real depth from
FacadeDresser: slab edges and cornices swept along the floor lines (they hug rounded bays and corners, found by rays cast at each tower's own mesh), wall AC units, downpipes, and rooftop water tanks, air-handling units and antenna masts from a facade kit generated in Blender (scripts/blender/make_facade_kit.py). Each tower's kit is one mesh, lit like the walls and dropped at a distance;--no-facade-kitturns it off for comparisons. Lit windows also light the wall around them. - Modern street lamps generated in Blender (
scripts/blender/make_streetlamp.py).
Sound
- Engines are synthesised in real time (
HypercarEngineSynth): firing pulses through an exhaust pipe resonator, firing harmonics, low-order crank growl, induction roar, a motor-generator whine, turbo whistle and blow-off, overrun pops, and gear-shift ignition cut, plus wet-tyre hiss and wind. Rivals are 3D with smoothed Doppler. - Cockpit view muffles the exhaust (
3.4 kHzcabin low-pass), attenuates exterior road and wind noise, and adds rain drumming on the roof; street-canyon reverb outside, long concrete reverb in the tunnel. - Rainy night air, late-night Tokyo-style traffic, neon buzz near signs, steam vents and hover-car flybys.
- Megacity Metro's soundtrack in two intensity layers (calm in menus, full while racing) or three alternate synth tracks, gently ducked by engine throttle and countdown beeps.
Vehicle profiles live in Assets/Resources/Cars/ (*.json) and are loaded by CarCatalog. Open GARAGE from the title screen to step through the six playable cars (PREV CAR / NEXT CAR or Left / Right), inspect the car on the showroom turntable, and choose a paint finish; the selected car persists in PlayerPrefs (neon.car) and can also be overridden from the command line with --car <id>. In STREET RACE, the three AI rivals use different models from the catalogue with distinct paint finishes and three-level LODGroup meshes (LOD0 / LOD1 / LOD2). Car materials are set in linear terms by NeonSceneBootstrapper.ApplyVehicleMaterialsToHierarchy: deep metallic paint under a clear coat (the base is darker and less saturated than the garage swatch, CarPaint.BaseColor), dark matte tyres, trim and grilles, fine carbon weave, dark machined rims, and a soft contact shadow under each car. Street props are capped at matte and mid grey. In first person every playable car uses the cockpit kit generated in Blender (scripts/blender/make_cockpit_kit.py): the driver sits on the left; a steering wheel generated from a concept image (Tripo image-to-3D, reduced to 40k triangles with its leather, carbon and stitching baked into 2K textures, see docs/asset-pipeline.md) turns with the steering; a slim floating cluster screen, a low dash with vents and a cyan light strip, a centre screen and console, thin A-pillars, a roof header and liner, door cards, and a rear-view mirror in a housing showing the road behind.
Car (displayName) |
ID | Archetype | Role |
|---|---|---|---|
| Mistral W16 | mistral_w16 |
Hypercar | Playable |
| Vanguard GT | vanguard_gt |
Mid-Engine Supercar | Playable |
| Brawler GTS | brawler_gts |
Heavy Muscle | Playable |
| Daytona Wedge | daytona_wedge |
80s Wedge Supercar | Playable |
| Strake Concept | strake_concept |
Cyberpunk Concept | Playable |
| Takumi 86 | takumi_86 |
Lightweight Tuner | Playable |
| Spectre XX | spectre_xx |
Track Prototype | Rival |
| Kodiak Utility | kodiak_utility |
Heavy Utility | Rival |
The HUD and menus are built in code with Unity uGUI (Assets/Scripts/UI/NeonUi/) on a ScreenSpaceOverlay canvas that scales cleanly from 1080p to 4K:
- Speedometer (bottom-right): 270° RPM ring with an always-visible redline segment, shift-light flash above 92 % RPM, inner nitro-boost arc, digital speed readout (
KM/HorMPH) and gear indicator (N,R,1–7). - Timing & splits (top-left): race position (
P1/4) orTIME TRIALheader, lap counter, live lap timer, personal best with colour-coded split delta, six sector grade bars (Purple,Green,Yellow, pulsingAmberon the active sector) and the current sector name. - Minimap (bottom-left): circular north-up track map with a glowing cyan spline, player heading arrow, rival dots and best-lap ghost dot.
- Countdown & banners: animated
3/2/1/GOlaunch sequence and fading sector-split banners, with the top-centre rear-view mirror corridor kept clear. - Screens:
- Title: game logo, tagline and main menu (
TIME TRIAL,STREET RACE,GARAGE,SETTINGS,CREDITS,QUIT). - Garage: live car and paint selector with model carousel, archetype badge, stat bars and colour swatches.
- Settings: four tabs persisted between sessions via
PlayerPrefs— Graphics (render resolution, screen-space reflections, volumetric light, motion blur, lens flares, film grain, chromatic aberration), Camera (default camera, cockpit FOV, seat height and seat forward, head motion, units), Audio (soundtrack, master volume, engine volume, music volume, ambience volume) and Accessibility (HUD scale, reduce flashing, performance overlay). - Credits: scrollable attribution list grouped by asset source.
- Pause & Results: in-race pause overlay with a live keyboard/gamepad controls card, and post-race finish summary (
TOTAL,BEST LAP,RACE AGAIN,TITLE). - Telemetry overlay (
F3/ benchmark mode): top-right FPS, 1 % low, frame time in ms, GPU label and 120-frame history bar graph with a 16.7 ms reference line.
- Title: game logo, tagline and main menu (
- Navigation: full keyboard, mouse and gamepad support with automatic keyboard and Xbox glyph hints that switch based on the active input device.
| Action | Keyboard | Gamepad |
|---|---|---|
| Accelerate | W / Up |
Right trigger |
| Brake / reverse | S / Down |
Left trigger |
| Steer | A / D, Left / Right |
Left stick |
| Handbrake / drift | Space |
South (A / Cross) |
| Nitro boost | Left Shift |
East (B / Circle) |
| Cycle camera (cockpit, bumper, chase) | C |
North (Y / Triangle) |
| Respawn on track | R |
Select / Back |
| Pause, settings, credits | Escape |
Start / Options |
| Performance overlay | F3 |
— |
Run from the repository root.
| Command | What it does |
|---|---|
./scripts/fetch-assets.sh |
Downloads and verifies the open-licence assets (cached in assets-cache/), then writes credits and logs provenance. |
python3 scripts/vendor_megacity.py |
Copies the selected Megacity Metro art (and everything it references) from a clone in vendor-cache/megacity-metro into Assets/Resources/ThirdParty/MegacityMetro, and updates the manifest. Needs git lfs pull in the clone. |
python3 scripts/make_generated_assets.py |
Rebuilds the Blender-generated assets and records them in the manifest. |
./scripts/build.sh |
Builds Assets/Scenes/Main.unity and the macOS app Builds/NeonRedline.app. |
./scripts/play.sh |
Launches the game at 1920×1080. |
./scripts/shots.sh |
Captures the seven track views to docs/screenshots/ and every menu and HUD state to docs/screenshots/ui/. |
./scripts/bench.sh |
Runs 60 Hz-capped and uncapped autopilot benchmarks into bench/. |
./scripts/audio_preview.sh |
Renders the offline scripted engine drive (docs/audio/engine_demo.wav) or benchmarks synth CPU cost (cost) and checks it. |
./scripts/audio_demo.sh |
Records the real in-game mix (docs/audio/ingame_demo.wav) or a solo group (--solo <group>) during an autopilot race and checks it. |
./scripts/audio_check.sh |
Runs the audio analyser on one or more WAV files via .cache/audio-venv. |
python3 scripts/audio_analyze.py |
Measures octave-band levels, flutter, organ tone, transient bursts, clipping, dropouts and ITU-R BS.1770-4 LUFS for WAV files. |
./scripts/audit.sh |
Checks the manifest, licences and code exceptions, then the provenance ledger. Exits non-zero on any violation. |
The game binary also accepts:
--shots --output-dir <dir> [--car <id>]: the seven track views.--ui-shots <dir> [--car <id>]: title, garage, settings, credits, countdown, chase and cockpit HUD, pause and results.--bench --output <json>: the benchmark.--audio-demo <wav> [--audio-seconds 40] [--audio-solo <group>]: records the in-game mix (or a single group) during an autopilot race.--render-scale <0.3–2.0>: forces the internal render scale.--neon-debug 1|2: shows the road's reflection colour, or reflection confidence and puddle mask.
In the editor, NeonRedline → Render Engine Audio Demo writes a scripted drive through the engine synth to docs/audio/engine_demo.wav.
Every asset file is listed in Assets/Manifest/manifest.json, credited in CREDITS.md, and logged in provenance/ledger.jsonl by the asset-provenance skill.
| Source | Licence | Used for |
|---|---|---|
| Unity Megacity Metro sample | Unity Companion License | Towers, storefronts, signage, skybridges, hover vehicles, airships, music |
| Poly Haven | CC0 | Props (barriers, pipes, bins, generators) |
| ambientCG | CC0 | Asphalt, concrete and facade materials, decals |
| Kenney | CC0 | UI sprites, keyboard and Xbox glyphs, particles, interface and impact sounds |
| Freesound (via Openverse) | CC0 | Rain, night traffic, rain on the roof, neon buzz, steam, tyre squeal |
BlenderKit (Seatla Morake — 95aa5be6) |
CC0 | Playable hypercar (Mistral W16) |
BlenderKit (Seatla Morake — b5914359) |
CC0 | Playable mid-engine supercar (Vanguard GT) |
BlenderKit (Seatla Morake — a169eb32) |
CC0 | Playable heavy muscle GT (Brawler GTS) |
BlenderKit (Seatla Morake — 828d733c) |
CC0 | Playable 80s wedge supercar (Daytona Wedge) |
BlenderKit (Seatla Morake — e4e122f4) |
CC0 | Playable cyberpunk concept (Strake Concept) |
BlenderKit (F.Z Studio — b49bbfa5) |
CC0 | Playable lightweight tuner (Takumi 86) |
BlenderKit (Seatla Morake — 2624e146) |
CC0 | Rival track prototype (Spectre XX) |
BlenderKit (Seatla Morake — afe62566) |
CC0 | Rival heavy utility wedge (Kodiak Utility) |
| Khronos glTF Sample Assets | CC BY 4.0 | Legacy fallback car (CarConcept) and best-lap ghost |
| incompetech (Kevin MacLeod) | CC BY 4.0 | Alternate music tracks |
| Google Fonts | OFL 1.1 | Orbitron, Rajdhani, Share Tech Mono, DotGothic16, Saira Condensed, Chakra Petch |
| Generated in-repo | Project original | Street lamp, facade kit and cockpit kit (Blender scripts) |
| Generated for NEON REDLINE | Project original | Steering wheel (Google Flow concept image, Tripo image-to-3D, reduced and fitted in Blender) |
scripts/audit.py rejects procedural meshes, procedural audio and runtime downloads in C# unless the code is marked with // audit-allow: <reason> (or an audit-allow-begin / audit-allow-end region); the audit prints every marked exception.
Apple M3 Max, 1920×1080, about 59 000 renderers and 6.8 M triangles: 125 FPS average uncapped (1 % low 93 FPS). Rendering at the 4K-with-STP internal resolution gives the same frame rate; the scene is CPU-bound.