Lab · Experiment
Last Light: one 3D game prompt, six models
The same prompt for a 3D ukiyo-e lighthouse game, given to six models. Every run is playable exactly as the model shipped it, with its own report.
Published
The prompt every model received
Build a complete, playable 3D browser game as a single HTML file named `last-light.html`. ## Game: "Last Light" You are the keeper of a lighthouse on a rocky coast during a night storm. Ships approach out of the darkness; guide them into the harbor before they hit the rocks. Core mechanics (resolve the details yourself, but keep them obvious to the player): - Rotate the lighthouse beam with the mouse. Ships caught in the beam steer toward the harbor; ships left in the dark drift toward the rocks. - The lamp burns oil over time. Collect oil barrels that drift ashore by clicking them. - The storm escalates: more ships, faster ships, higher waves, lightning flashes. - Score for every ship that docks. Game over after 3 wrecks or when the oil runs out. - Start screen, game over screen, restart. ## Art direction A 3D scene rendered as a living Japanese woodblock print (ukiyo-e): cel/toon shading, ink outlines, a limited palette (indigo, Prussian blue, off-white paper, one vermilion accent), and paper grain. Animated ocean with stylized curling waves, rain, and a visible light cone from the beam cutting through fog. The camera should frame the scene cinematically. All geometry, textures, and effects must be procedural; no external models, images, or fonts. ## Eval panel A small panel in the corner, toggled with E, showing live-measured values (never hardcoded): - FPS (current and average) and 95th-percentile frame time in ms - Draw calls and triangle count per frame - Number of runtime errors caught - Active entities in the scene Also show a `MODEL_REPORT` defined at the top of the script: - `featuresImplemented`: an honest list of what from this spec you implemented - `knownLimitations`: an honest list of what is missing or simplified ## Constraints - Three.js from a CDN is allowed (pin the version); no other external dependencies. - Must run in a current desktop browser. - Build it in steps if needed.
Runs
6 of 6 published
PlayOpus 5.5
PublishedModel report · captured
Implemented, as the model reports it
- Single HTML file; Three.js 0.160.0 pinned via importmap (jsdelivr); everything else (geometry, textures, audio) generated in code
- Mouse-aimed lighthouse beam with smoothed rotation; one 2D "lit" test (azimuth + range from the lamp) shared by gameplay, the light pool on the water, ship/rock shading, rain and mist
- Lit ships steer for the harbor via an approach waypoint with rock/shore avoidance; guidance lingers ~2.6 s after the beam leaves them
- Unlit ships turn toward an assigned rock (always within beam reach) and are pushed by a storm current; vermilion warning triangle + dashed line when a wreck is near
- Wrecks on rocks or shore (sinking + spray + camera shake); docked ships glide behind the breakwater and moor
- Scoring per ship type: sampan 1, bezaisen 2, kitamae 3; docked count, survival time and best score (localStorage)
- Lamp oil drains continuously; under 22% the beam flickers and shortens; barrels drift toward shore and are collected by clicking (+20 oil), or lost on rocks/shore
- Storm escalation over time: spawn rate, concurrent ship cap, ship speed, wave height, foam, rain density, wind, lightning frequency, oil burn; visuals saturate at level IX, while ship pressure keeps building to XVI (shorter beam memory, faster drift)
- Difficulty measured with a perfect-reflex autopilot bot (smoothed beam, has to aim at barrels to click them): it lasts ~7 min (417-430 s over 4 runs) before 3 wrecks; every single lit ship from any spawn point docks, at storm I and VIII
- Lightning: procedural bolt, sky and scene flash, delayed thunder, camera shake
- Game over after 3 wrecks or an empty lamp; start screen, game-over screen with stats, restart by button / Enter / Space; P pause, M mute
- Ukiyo-e look: 3-band toon shading with hatching in shadow, inverted-hull ink outlines (smoothed normals, fogged), depth-edge ink lines and paper grain + vignette in a post pass, limited indigo / Prussian blue / paper palette with vermilion accents
- Ocean: displaced sum-of-sines mesh mirrored in JS for bobbing; printed colour bands, carved contour lines, crest foam with ink rims and foam dots, foam rings around rocks, shore surf
- Stylised curling wave crests (canvas-drawn Hokusai-style curl) riding the highest nearby crests, more as the storm grows
- GPU-animated rain that brightens inside the beam; kasumi mist bands; volumetric-looking beam cone with scrolling fog noise in tonal steps; banded sky with ink-edged storm clouds and a veiled moon
- Cinematic camera: title framing, dolly into the keeper view, letterbox bars, slow sway, shake, game-over pull-back
- Synthesised WebAudio: rain + surf bed scaled by storm, thunder, dock chime, wreck crash, barrel pickup, horn
- Eval panel (E): FPS over the last second and since load, mean and 95th-percentile frame time over the last 600 frames, draw calls / triangles / points / lines summed over both render passes, runtime errors (window error + unhandledrejection + try/catch around the loop), active entity breakdown
Known limitations
- Waves are a sum-of-sines heightfield; the "curling" waves are textured point sprites riding it, not 3D breaking-wave geometry
- The visible beam cone is pitched down and flattened; near the tower it passes above ships, while "lit" is a 2D test, so the light pool on the water is the exact indicator
- Beam light is analytic in the shaders: no shadows or occlusion (the beam passes through rocks and ships)
- Ship steering is waypoint + repulsion, not physics; ships do not collide with each other
- Docked ships are scaled down slightly when they enter the small harbor, and only the last 3 stay moored
- Paper grain is fixed to the screen, like a print, not to the world; kasumi mist bands are fixed flat planes
- Text uses system serif fonts (Hiragino / Yu Mincho / Georgia fallback), so typography varies by OS
- Built for desktop mouse; touch and small screens are untested
- Performance was only measured in headless SwiftShader (software rendering, ~18-21 FPS at 1280x720); real-GPU frame rates were not verified by the author
- Draw-call and triangle counts cover the WebGL passes only; the 2D overlay canvas (markers, course lines) is not included
- Needs network access to load Three.js from the CDN; shows a message if it or WebGL fails
- Audio is basic synthesis (filtered noise + oscillators), with no music
PlaySonnet 5.5
PublishedModel report · captured
Implemented, as the model reports it
- Mouse-aimed lighthouse beam (smoothed, rate-limited turn); ships inside the cone steer for the harbor channel, ships in the dark drift slower and veer onto the reef; a short guidance grace period after the beam leaves a ship.
- Oil system: lamp burns oil continuously (faster as the storm grows), beam narrows/dims/flickers when low; oil barrels drift in, beach on the shore, and are collected by clicking them (forgiving screen-space hit test).
- Score per docked ship (by ship type) with a streak multiplier; 3 wrecks or empty oil ends the game. Start screen, game-over screen with stats and local best score, restart via button, Enter/Space or R.
- Storm escalation over ~3.5 minutes and beyond: more simultaneous ships, faster ships, bigger wave amplitude, denser rain, louder wind, more frequent lightning (flash + bolt + delayed thunder).
- Three ship types (skiff, junk, freighter) built procedurally and bobbing/rolling on the same wave function the ocean shader uses; wreck debris, ripples, floating score texts.
- Ukiyo-e look: custom cel-shading (3 tone bands, fog quantised into bands), screen-space ink outlines from a depth Laplacian with hand-cut wobble, paper grain/fibres, print border, indigo/Prussian/paper palette with vermilion accents (moon, lamp roof, barrels, lanterns, HUD).
- Animated GPU ocean (4 summed waves) with banded colour, contour water lines, foam crests and reef surf; additional stylised extruded curling "claw" waves at the flanks; stepped-cloud sky with a vermilion moon.
- Visible light cone: additive fog-like beam cone plus an analytic lit pie-slice on sea, ships and rocks; lamp halo.
- Everything procedural: geometry, shaders, textures (canvas), audio (WebAudio). Only dependency: three@0.160.0 from jsdelivr.
- Eval panel (E): FPS current/average, p95 frame time (300-frame ring buffer), draw calls and triangles per frame (renderer.info with manual reset across both passes), caught runtime-error count (window error, unhandledrejection, console.error, loop try/catch), live entity counts, plus this report.
Known limitations
- Only verified in headless Chrome with a software (SwiftShader) renderer: it loads with 0 errors, and the game flow and visuals were checked via screenshots. Real-GPU frame rates were not measured and no other browser was tested.
- Balance was tuned by reasoning and a simple autopilot, not by human playtesting; difficulty may be too hard or too easy.
- The ocean surface is a sum of sines with stylised shading; true curling waves exist only as decorative extruded meshes at the left/right flanks and never interact with ships.
- Ink outlines come from a depth-discontinuity post pass, so only silhouette-type edges are inked; there are no interior crease lines, and the waterline contact has no outline.
- The beam is an additive cone plus an analytic azimuth test: no real volumetric scattering, no shadows from rocks, and ship hit-testing uses a 2D angle test.
- Ship motion is simple kinematics (no hydrodynamics, no currents); ships only avoid each other with a soft push; ships docked in the harbor simply vanish after a moment.
- Mouse only: no touch or gamepad support, no pause. Audio is a minimal synthesised sketch (wind, thunder, a few tones) and starts only after the first click/key.
- Text uses system fonts; Japanese glyphs depend on the OS having a CJK font. The paper border trims a little of the viewport.
- Active-entities count includes decorative curl waves and rain streaks (broken out in the panel); scene-object count is a separate traverse of visible meshes.
PlayHaiku 5.5
PublishedModel report · captured
Implemented, as the model reports it
- Lighthouse beam aimed by the mouse (raycast onto the sea plane), with smoothed rotation
- Ships inside the beam steer to the harbor with rock avoidance; unlit ships steer onto their assigned rock
- Wrecks on rocks (3 ends the game); docking scores points
- Oil drains over time; clickable oil barrels drift ashore and refill the lamp
- Escalation driven by elapsed time: spawn rate, ship speed, wave height, lightning frequency, rain density
- Procedural 3D scene: CPU-displaced ocean with foam crests, rocks, lighthouse, ships, barrels, curling wave arcs, rain as one LineSegments draw, moon
- Toon shading via a 4-step gradient map, ink outlines via inverted hulls, indigo/Prussian/paper palette with vermilion as the single accent
- Light cone through fog, paper-grain overlay, lightning flashes
- Start screen, game over screen, restart (all ships and barrels removed and re-created)
- Eval panel (E): live FPS current and average, p95 frame time, draw calls, triangles, runtime errors, active entities
Known limitations
- Art style is an approximation of ukiyo-e: toon shading and outlines only, no hand-carved textures or woodblock registration
- Paper grain is a CSS overlay, not a shader effect
- Fog is linear distance fog, not volumetric; the beam is a simple additive cone
- Wave displacement is computed on the CPU per vertex each frame (about 10k vertices), not in a shader
- No audio; lightning is visual only
- Camera has only a slow sway, not a scripted cinematic move
- Ships do not collide with each other
- Controls are mouse/pointer only; touch works only through pointer events and is not tuned
- Typography uses system serif fonts only
- Beam is faint against the dark sky; the light cone reads better as a foreshortened disc from the default camera
- Balance is untested by a human player: game logic was checked with a scripted harness (steering, docking, barrel clicks, game over, restart), not by playing
- FPS and frame-time numbers come from headless Chrome on software rendering (about 6 fps), so they say nothing about a real GPU
- Three.js is pinned to 0.160.0 via jsDelivr; the page needs network access to load it
PlayArgos 4.0
PublishedModel report · captured
Implemented, as the model reports it
- Mouse-steered volumetric lighthouse beam with water-surface light projection and aim reticle
- Autonomous ship navigation: ships caught in beam turn and sail toward the Harbor Torii; ships in darkness drift toward sea reefs and rocky coast
- Continuous lamp oil consumption with clickable drifting/washed-up oil barrels featuring generous hitboxes and pulsing rings
- Escalating storm difficulty: faster spawn cadence, higher ship speeds, taller curling waves, stronger wind drift, and procedural lightning flashes
- Score tracking for docked ships, 3-wreck tracking with traditional hanko seals, oil depletion loss condition, start/game-over/restart flows
- Ukiyo-e woodblock art direction: custom GLSL cel/toon stepped shaders, inverted-hull ink outlines, strictly limited indigo/Prussian/off-white/vermilion palette, and procedural Washi paper grain + woodblock lines overlay
- Animated ocean with vertex-displaced wave ridges, dynamic 3D curling Hokusai foam crests, slanting rain, and sea spray
- Live-measured Eval Panel (toggled with E) tracking current/average FPS, 95th-percentile frame time, draw calls, triangle count, runtime errors, and active entities
- Procedural Web Audio API storm ambiance, wave crashes, ship bell chimes, barrel pickup, and wreck thunder
Known limitations
- Curling wave foam claws are stylized procedural 3D rib meshes rather than full fluid-simulation meshes to maintain 60 FPS in a single file
- Ink outlines use inverted-hull meshes and shader contour bands rather than a multi-pass depth/normal post-processing pipeline
- Ship pathfinding around mid-sea rocks relies on local repulsion + beam attraction steering rather than grid A* navigation
PlayGPT Sol 6.1
PublishedModel report · captured
Implemented, as the model reports it
- A complete single-file 3D lighthouse survival game with start, pause, game over and restart screens.
- Mouse-directed lighthouse beam; illuminated ships steer to harbor and gradually lose their course in darkness.
- Docking score, three-wreck defeat, finite lamp oil, and clickable procedural barrels that drift ashore.
- Escalating ship frequency and speed, wave height, rain and randomized lightning.
- Procedural toon-shaded lighthouse, rocky coast, harbor, sailboats, curling waves, rain, fog and visible beam.
- Indigo / Prussian blue / paper / vermilion palette, geometry ink outlines, carved sea lines and generated paper grain.
- Optional synthesized storm audio and event sounds; keyboard pause, sound and telemetry shortcuts.
- Live current and average FPS, rolling p95 frame time, actual renderer draw calls and triangles, caught errors and scene entity counts.
- This report is shown inside the E-toggle telemetry panel. Responsive UI and automatic pause on loss of focus.
Known limitations
- Wave motion and ship steering use analytic animation and arcade rules; there is no fluid or rigid-body simulation.
- The visible beam uses layered transparent geometry and a sea shader; fog is artistic rather than physically volumetric.
- The camera is fixed and cinematic. Mouse and desktop browsers are the intended input and platform.
- Three.js 0.160.1 is the only dependency and loads from a CDN, so the initial load needs an internet connection.
- Best score lasts for this page session. Audio is synthesized; there are no recorded sounds or external assets.
- FPS and p95 measure browser animation frame intervals, not GPU timings. Renderer counts exclude DOM overlays.
PlayGPT Luna 6.0
PublishedModel report · captured
Implemented, as the model reports it
- Procedural 3D lighthouse coast, harbor, boats, rocks, clouds, rain, and curling wave marks
- Ukiyo-e inspired limited palette, toon shading, ink outlines, and procedural paper grain
- Mouse-aimed volumetric beam that guides ships toward the harbor
- Dark ships drift toward coastal hazards; three wrecks end the game
- Click-to-collect drifting oil barrels; oil drains and empty oil ends the game
- Escalating ship traffic, ship speed, wave height, rain, and lightning
- Start screen, score and status HUD, game over screen, and restart
- E toggled live eval panel with measured frame, renderer, error, and entity metrics
Known limitations
- The game uses a stylized isometric view rather than a freely orbiting camera
- Ship handling is an automatic steering simulation controlled by beam coverage
- Rain and lightning are visual only; no sound or persistent high score is included
- The scene uses lightweight procedural shapes and does not model detailed ship damage