deepseek v4.1 flash built a parkour run with the best effects of four

deepseek v4.1 flash 1017 built a first-person parkour run with the richest effects of four flash models, for 14 cents. claude haiku 5.5, gpt-6 luna and qwen3.8 flash got the same brief. the job: a free runner on autopilot in one html file, built in four stages.

the setup

every model got the same brief in four stages: run and moves, hands and camera, world, then effects and sound. after stage four we ran each file for 50 seconds. then each model got one fix round with a list of its own bugs.

• models: deepseek v4.1 flash 1017, claude haiku 5.5, gpt-6 luna, qwen3.8 flash
• deepseek, luna and qwen through openrouter, haiku through a claude subscription
• every reply is the full html file, reasoning on medium, 60k max tokens per reply
• three.js 0.170 from a cdn, every texture and sound made in code, no browser for the models
• test date: oct 17, 2026

the world, the look and the effects are each model's own idea.

the numbers

cost is what openrouter billed, time is generation time across all five prompts. tokens include reasoning.

*haiku ran on a subscription, so its cost and tokens are our estimate from the code it wrote at openrouter prices. its hidden reasoning is not counted.

deepseek wrote almost 5x more tokens than luna and still cost 14 cents for the whole game.

deepseek: a city of glowing windows

deepseek picked a rooftop run over a city at sunset. after stage four its buildings were missing: one broken shader for the windows stopped them from drawing, and the console showed the shader error.

one fix round later, the same shader lit the whole skyline.

• bloom, chromatic aberration and a lens flare on the sun
• thousands of lit windows, clouds, birds and sparks
• gloves with cuffs and a speed and timer hud

no other model shipped this many of the effects the brief asked for.

the other three

haiku built the only world that reads as a city at first glance. luna and qwen stayed darker and plainer.

• claude haiku 5.5 – lit windows, a violet sunset, railings and speed lines in 23 minutes
• gpt-6 luna – the fastest and cheapest by far, with the plainest world
• qwen3.8 flash – spent 56 minutes and 172k tokens on stage one alone, then hid its world in haze

all four runs render with zero console errors after the fix round.

what went wrong on the way

reasoning ate the budget twice. qwen thought for 26 minutes on stage one and returned an empty reply at 60k max tokens. one deepseek attempt did the same on stage two. both got a fresh retry with a bigger limit.

the brief

the same text went to all four models, one stage at a time:

You are building a complete, polished real-time 3D experience step by step: a FIRST-PERSON PARKOUR RUN. You will receive the work in 4 stages. In every stage you get your current code and the next part of the brief, and you reply with the COMPLETE updated HTML file (never a diff, never "the rest stays the same").

THE EXPERIENCE
- First-person view of a free runner moving non-stop through a world of YOUR OWN design — choose the setting, mood and look yourself and make it memorable. The runner's arms and hands are visible and animate with the movement.
- Parkour moves along the route: sprinting, long gap jumps, wall-running along a wall (camera tilts towards the wall), wall-jump from one wall to the opposite one, vaulting over obstacles, sliding under something low, climbing up a ledge (hands grab the edge, pull up), a roll on a hard landing, a drop down to a lower level, balancing across something narrow.
- The camera must FEEL the body: head bob and sway in sync with footsteps, a quick FOV kick when speeding up and on jumps, a dip and shake on landings, tilt during wall-runs, slight motion blur / speed lines at top speed. Smooth, never nauseating, always readable.
- One run lasts about 40–60 s, then fades and restarts.

AUTOPILOT (required)
The run plays by itself with nobody touching anything — it will be recorded for a video. The route is a fixed designed course, and the runner is driven along it by a movement controller (speed, gravity, jump arcs, wall-run, vault, slide timing), not by a simple camera spline: feet must land on real geometry, jumps must clear real gaps. Optional: pressing a key toggles manual control (WASD + mouse look + Space jump), but the autopilot is what matters.

TECHNICAL RULES (all stages)
- ONE self-contained HTML file. three.js only, loaded through an importmap from https://cdn.jsdelivr.net/npm/[email protected]/ (build/three.module.js and examples/jsm/ addons are allowed). No other libraries, no external models, textures, images or fonts — all geometry and textures are made in code (canvas textures, procedural shaders).
- The scene must FILL the whole window. It may be shown as small as 930x380 (wide and low!) and as large as 1920x1080; handle resize and keep the horizon and the hands well framed at both extremes.
- Starts immediately, no menu, no click needed. body margin 0, no scrollbars.
- Smooth 60 fps on a mid-range GPU: merge or instance repeated geometry, reuse materials, cap pixel ratio at 2, no per-frame allocations in hot loops.
- requestAnimationFrame loop with delta time clamped (max 50 ms).
- Zero runtime errors: declare every variable you use, guard against undefined, double-check every function, variable and three.js API name you reference.

Reply with the complete HTML file only — no explanations, no markdown fences.

STAGE 1 of 4 — COURSE, MOVEMENT CONTROLLER AND AUTOPILOT
Build the whole working run with simple blockout graphics (plain boxes, flat colours, basic lights):
- The course: a designed route with plenty of height variation that winds left and right rather than going in a straight line. Place on it, in a good rhythm: at least 4 gap jumps, 2 wall-runs (one left, one right), 1 wall-jump between two close walls, 2 vaults, 1 slide, 1 ledge climb, 1 drop to a lower level with a landing roll, 1 narrow beam to balance across.
- A first-person movement controller with real physics: run speed with acceleration, gravity, jump arcs, ground detection against the course geometry (box colliders are fine), wall-run with reduced gravity and a timer, wall-jump impulse, vault (short hop over an obstacle), slide (lower camera, keep momentum), ledge climb (move up and over the edge), landing detection with a roll when the fall is high.
- The autopilot: a list of route waypoints with the action to perform at each (jump here, start wall-run here, slide here...), steering towards the next waypoint; actions triggered by distance so the runner hits every move cleanly. If the runner ever falls off, respawn at the last checkpoint with a quick fade.
- A basic first-person camera with head bob already in.
- The run loops: after the end of the course, fade out and restart from the beginning.
Placeholder graphics are fine; a smooth, convincing, uninterrupted run is what matters in this stage.

STAGE 2 of 4 — HANDS, BODY AND CAMERA FEEL
Make it feel like being in a real runner's body:
- First-person arms and hands built from smooth geometry (lathe / capsule / tube shapes, not boxes): sleeves with fingerless gloves, visible fingers. Rendered on top of the world (separate pass or depth trick) so they never clip into walls.
- Procedural arm animation for every move: alternating pumping while sprinting, both arms forward and up on a jump, one hand brushing along the wall during a wall-run, both hands planting on the obstacle during a vault, hands grabbing the edge and pushing down on a ledge climb, arms tucked in a roll, arms out for balance on the beam.
- Glimpses of the legs/feet when looking down during slides, vaults and landings.
- Camera feel: head bob and side sway locked to the footstep rhythm; FOV rises with speed (e.g. 75° → 90°) and kicks on jumps; landing dip with a short spring back and a small shake scaled by fall height; camera tilt up to ~15° towards the wall during wall-runs; a full forward rotation during the landing roll; smooth look-ahead that turns the view towards the next move a moment before it happens.
- Speed lines or a radial motion-blur feel at top speed.
Keep all stage-1 movement, the course and the autopilot working.

STAGE 3 of 4 — THE WORLD
Turn the blockout into a beautiful world in the setting you chose:
- Every part of the course gets real detail fitting your setting (edges, railings, props, surface wear, small objects that sell the scale). Keep the colliders from stage 1.
- A big surrounding environment that reaches the horizon: lots of instanced scenery, varied heights and shapes, a distant backdrop fading into atmosphere — the runner must feel small inside a huge place.
- Rich procedural materials and textures (canvas or shader): no flat untextured surfaces left.
- A strong mood: a sky that fits the setting, fog / haze with depth, a clear lighting direction with warm/cool contrast, ambient life in the air (particles, birds, drifting things, moving lights — whatever fits).
- At least one spectacular moment on the route where the view opens up dramatically (e.g. a huge jump over a wide space with the whole world visible below).
Keep all earlier movement, hands, camera feel and the autopilot working.

STAGE 4 of 4 — POST-PROCESSING, SOUND AND POLISH
Make it look and sound like a finished viral clip:
- Post-processing with three.js EffectComposer: bloom, subtle chromatic aberration and vignette, ACES tone mapping, sRGB output, plus any grading that suits your setting.
- Shadows from the main light on the course and the hands (one directional light with a tight shadow camera following the runner).
- Effects: dust or debris on landings, a streak of wind particles at top speed, lens flare when looking towards the light source, small reactive details (things scattering as the runner passes).
- A minimal HUD: a tiny speed readout and a run timer in a style that fits the world; nothing else on screen.
- Sound with the Web Audio API only (no files): footsteps synced to the stride, breathing, wind whoosh that rises with speed, jump / landing thumps, wall-run scrape, and a fitting music loop. Start audio on the first click or key press (browser autoplay rules), but everything else must run silently without any input.
- Final pass on the autopilot so the recording is perfect: no stalls, no falls, varied rhythm, the most dramatic move at the climax of the run.
- Performance and robustness: steady 60 fps, no console errors, correct framing at both 930x380 and 1920x1080.
Keep everything from stages 1–3 working.

no model saw another model's code, and the fix round was the only extra turn.

our take

for 14 cents, deepseek v4.1 flash 1017 delivered the most effects of the four. the price is time: almost an hour and a half against 23 minutes for haiku and 8 for luna. if you can wait, it is the cheapest way here to a flashy scene. if you need it fast, luna is 4x cheaper and 10x quicker. its world is much plainer.

sources

• deepseek v4.1 flash 1017 on openrouter
• claude haiku 5.5 on openrouter
• gpt-6 luna on openrouter
• qwen3.8 flash on openrouter
• brief, builds, timings and bills: our test, oct 17, 2026