Kimi K3 vs Fable 5 vs GPT-5.6

# Build Prompt — Charybdis: The Whirlpool

A single build. A real-time, controllable open-sea scene from *The Odyssey*: Odysseus'
galley caught at the edge of **Charybdis, the great whirlpool**, with **Scylla's** cliff
looming on the far side of the strait. This is a graphics-and-feel showpiece. It has to
look like a **2026 AAA video game** — real dynamic lighting, real materials, real depth —
not a tech demo. Everything is generated in code.

---

You are a world-class real-time graphics engineer working in the browser. Build a
production-quality, full-screen, interactive ocean-and-whirlpool scene using **WebGPU via
Three.js (WebGPURenderer + TSL)**, native ES modules, no build step.

**Ground rule on assets:** build ALL geometry and ALL materials procedurally, in code —
no pre-made 3D model files, no downloaded image textures, no HDRIs. You MAY use Three.js
and its official addons, plus open-source *libraries* for simulation, physics, and
post-processing (e.g. a physics engine like `@dimforge/rapier3d` or `cannon-es`, an FFT
ocean reference such as the technique in `jbouny/fft-ocean`, `lil-gui` for controls). The
point is that YOU build the ship, the figure, the whirlpool, and every texture from math —
libraries are for the hard rendering/physics plumbing, not for the content.

## The single most important thing: it has to look REAL

The last version of a scene like this failed in one specific way: **the ocean was okay,
but the ship read as a flat, dimensionless blob and the figure on it looked like a stick
figure.** That cannot happen again. The ship and the figure have to hold up in a close-up.
Hit the realism bar below on every element, and do not stop until they all clear it.

### Ocean (physically-based, FFT-driven)
- Drive the surface with an **FFT / Tessendorf ocean spectrum**, ideally **multi-cascade**
  (2–3 frequency bands: long swell + chop + capillary ripples) rather than a handful of
  Gerstner waves. Derive correct normals and the **Jacobian** for foam.
- **Persistent, rolling whitecap foam** that accumulates where waves steepen and break, and
  lingers/streaks off the crests. **Spray and mist** off the tops in wind.
- **Physically-based water optics:** color absorbs with depth (bright over shallows, deep
  saturated blue-green in the trough), **Fresnel** reflectance, **subsurface scattering**
  glow through backlit crests, **sun glitter**, and **screen-space reflections (SSR)** so
  the ship, cliff, and sky land on the water. Fog to the horizon.

### Charybdis — the whirlpool (the hero effect)
- A genuine, physically-suggestive **vortex**: the ocean surface spirals down into a
  **funnel** that punches below sea level, water accelerating and stretching toward the
  throat, with a dark churning core and a ring of breaking foam around the rim.
- Downdraft **spray/particle** system pulled inward and down. The whole thing is **live and
  animated**, with a `whirlpoolStrength` control that grows it from a swirl to a
  ship-swallowing maelstrom.
- The galley responds to it: buoyancy plus the vortex's inward/rotational pull, so the ship
  **lists, spins, and gets dragged** toward the throat as strength rises.

### The galley (this is where it must not be a blob)
Build a believable **Homeric-era Greek galley** as real 3D geometry with volume and correct
proportion, close-up-worthy:
- **Hull:** loft it from spline cross-sections (a keel line + ribs + a smooth planked
  skin), a **high curved sternpost and prow**, a painted **oculus (eye)** on the bow. Real
  thickness — you should be able to orbit it and see a solid, hollow-decked ship, not a
  slab.
- **Materials (PBR):** use `MeshPhysicalMaterial`-equivalent with **procedural wood-grain**
  (albedo + roughness + normal generated from noise), plank seams, tar/pitch darkening at
  the waterline, salt/wetness sheen (**clearcoat**), and weathering. Bronze fittings with
  proper metalness.
- **Rig:** mast + yard (TubeGeometry), a **square sail** as a real subdivided cloth that
  **billows and luffs** via position-based / spring cloth sim driven by wind, ropes/rigging
  as thin tubes, banks of **oars** along both sides.
- **Ambient occlusion** in the crevices so it reads as solid.

### Odysseus and the crew (no stick figures)
- A **properly-proportioned humanoid** figure — real head, torso, arms, legs with correct
  scale — braced at the helm, plus a few crew at the oars. Segmented or lightly skinned
  bodies with **PBR skin and cloth (tunic/cloak)**, simple believable poses that react to
  the pitch and roll. Stylized is fine; **stick-figure or featureless-blob is a fail.**

### Lighting & rendering pipeline (name-checked, all required)
- **Image-based lighting:** generate a procedural HDR sky and turn it into an environment
  map with **PMREM** for real reflections/ambient. **Physically-correct sun** as the key
  light.
- **Cascaded shadow maps (CSM)** so the ship and cliff cast crisp shadows on the water and
  themselves. **SSAO** for contact shadowing. **ACES filmic tone mapping** + **bloom** on
  the sun/foam/spray. Optional **depth-of-field** for the cinematic beats.
- Run a real **post-processing pipeline** (TSL/EffectComposer): SSAO → SSR → bloom → DoF →
  ACES output. Correct **linear/sRGB** color management throughout.

## Scylla (the far side)
On the opposite cliff of the strait, suggest **Scylla** — a rock-bound, many-necked
silhouette that occasionally lunges. It doesn't need to be the focus; it frames the danger.

## Feel & interactivity (make it play like a game)
- Free-orbit camera **and** a cinematic "follow the ship" rig with slight shake near the
  vortex. Smooth, damped, no snapping.
- A clean control panel (`lil-gui`): `whirlpoolStrength`, sea state / wind, time of day,
  camera mode, and a live **FPS** readout. Let the viewer crank the whirlpool and feel the
  ship get taken.
- Steering: let the player nudge the galley (rudder/oars) to fight the pull — it should
  *feel* like you're losing a battle with the sea as strength climbs.

## Runtime handling (required)
WebGPU detection with a graceful message, loading and failure states, resize, touch,
capped DPR, hidden-tab pause, `prefers-reduced-motion`, accessibility, and performance
safeguards (LOD / throttling so it holds a smooth frame rate). Live FPS readout.

## Standards & iteration — do not stop early
This is judged on how real and how alive it looks. **Do not consider it done until every
element above clears the realism bar.** After you build it, **render it, screenshot your
own output, and inspect it** — the ocean, the whirlpool, and especially the ship and the
figure in close-up. If the ship reads flat, if the figure reads like a stick, if the water
looks like noise instead of a real sea — **fix it and go again.** Do a minimum of **three
full self-review-and-improve passes**, more if it's not there yet. No placeholders, no
invented APIs, no console errors, no hidden fallback rendering.

## Deliverable
Complete, directly runnable code (index.html + JS modules, and any pinned library imports)
plus brief launch instructions. It must run at a smooth frame rate and look like a modern
game.

# Build Prompt — The IMAX Keighley

One self-contained prompt. Build a single-page, scroll-driven website about **The IMAX
Keighley** — the real next-generation 65mm film camera Christopher Nolan used to shoot
*The Odyssey*, the first feature shot entirely on IMAX film. The camera is the centerpiece:
a photoreal 3D camera the visitor explores, that **disassembles into an exploded view as
they scroll** and reassembles, and that at the end **they actually operate** — pointing it
at a live Odyssey scene and shooting it. Everything is built in code.

The bar for the camera is not "recognizable." It's **as close to a photoreal, exact
replica as you can get in real time** — it should almost look like a photograph of the real
camera, rendered like a 2026 AAA game. Do not stop until it clears that bar.

---

You are a world-class creative front-end + real-time 3D engineer. Use **Three.js
(WebGPURenderer + TSL where it helps), native ES modules, no build step. Build the camera
and all geometry procedurally from primitives — no imported 3D models, no image textures,
no HDRIs.** You MAY use Three.js official addons and open-source libraries for the
rendering/scroll/post plumbing (e.g. `lil-gui`, a scroll library, post-processing passes) —
but the camera, its parts, and every material are built by you, in code.

## The camera — build an accurate IMAX Keighley (real reference)
The Keighley is a **carbon-fiber-bodied large-format film camera** — a radical departure
from the old bulky aluminum IMAX housings. Build it as **separable, nameable parts** so the
exploded view can pull them apart, and get the proportions and detailing right so it reads
as a real machined device up close:
1. **Carbon-fiber body** — a compact, boxy-but-refined main housing with visible **woven
   carbon-fiber panels**, panel seams, recessed hex screws, vents, and a matte finish.
2. **Large central lens assembly** — a substantial large-format prime on a **PL-style
   mount**, with focus/iris rings, lens barrel markings, a front element with real glass,
   and a **matte box** with flags.
3. **Film magazine** — the reloadable 15-perf 70mm chamber mounted on top/back; holds only
   ~2.5–3 min of film per load. Show the **film path + gate** where the 70mm runs through
   horizontally; animate film moving (it runs ~5.6 feet per second at 24 fps).
4. **Body-mounted digital LCD telemetry screen** — the camera's signature modern touch.
   Render a live, glowing readout with real-looking data: **frame rate (23.999 / 24.000
   fps), film remaining (e.g. "Rem: 00:42"), temperature (~26°C), voltage/current (35.5V /
   3.2A), and a status line ("Local 230.7 Forward").** This detail sells authenticity.
5. **Reflex viewfinder** mounted top-right, with a small **video-tap** module feeding
   external monitors.
6. **The "blimp"** — the coffin-like acoustic housing the whole camera drops into (its own
   section). Fully rigged the system weighs 300–400 lb and needs steel-plated dollies.
7. **The mirror periscope** — a small twin-mirror arm that mounts beside the lens (its own
   section).
- Add **greebling**: cables, ports, labels, a red REC tally, rod mounts, a top handle,
  toggle switches — the small hardware that makes it read as a real camera, not a clean box.

## REALISM BAR — this is how it stops looking like a video-game prop and starts looking real
Name-check every one of these; all required:
- **PBR metallic-roughness materials:** procedural **carbon-fiber weave** (albedo +
  roughness + normal generated from math), **anodized/brushed aluminum** fittings with
  correct metalness, **real glass** on the lens via `MeshPhysicalMaterial` (transmission,
  clearcoat, refraction, subtle chromatic dispersion), **rubber** grips, painted markings.
- **Image-based lighting:** generate a procedural **HDR studio environment** and convert it
  with **PMREM** so the metal reflects a real room and the lens catches proper highlights.
  This single thing is most of what makes it look photographed.
- **Studio lighting:** physically-correct **key / fill / rim** rig, **cascaded shadow maps**
  for crisp self-shadowing, **SSAO** in every seam and screw recess, **SSR** on the body.
- **Post pipeline:** **ACES filmic** tone mapping, **bloom** on the LCD glow and rim lights,
  **depth-of-field** (real bokeh) on the beauty shots, a whisper of **chromatic aberration**
  and **film grain** for the photographic feel, correct linear/sRGB color management.
- **Geometry quality:** beveled edges (no razor-sharp CG edges), chamfers, consistent panel
  gaps, high-enough tessellation on curves. The camera must survive a slow close-up orbit.
- **Micro-detail (the photographic touch):** subtle edge wear, fine scratches, faint dust
  and fingerprints on the metal and on the lens glass, **emulsion sheen and visible
  perforations** on the 70mm film, and the LCD rendered as a **real emissive panel** with a
  crisp anti-aliased readout and a faint glow. These small imperfections are what push it
  from "clean CG render" to "photograph of a real object."
- **Every state stays photoreal — this is required, not just the beauty shots:** the realism
  bar holds for the whole assembled camera in the hero, for **every floating part during the
  exploded view** (each part keeps its full PBR materials, ambient occlusion, and
  reflections, and casts and receives shadows on the neighboring parts), and in the finale.
  Depth-of-field follows whatever part or subject is currently in focus; everything else
  falls off with real bokeh. Lighting, reflections, and shadows stay consistent as the parts
  separate and come back together — the camera can never flatten into shaded boxes while it's
  apart.

## Scroll experience — section by section
Use the **15/70 film strip as the scroll motif**: a thin strip of film runs down the side /
through the gate as the visitor scrolls, tying the sections together; scrubbing feels like
running film.

**1 — Hero.** The fully assembled Keighley, slowly rotating, dramatically lit against
near-black, shallow depth of field. Oversized headline: **"THE KEIGHLEY."** Subhead: *"The
camera behind the first film shot entirely on IMAX."*

**2 — The format.** The camera centers and the **film threads through the gate and
magazine**, running horizontally. Copy: *"15-perforation 65mm film — 'IMAX 15/70,' the
largest format in cinema. It moves more than five feet of film a second. That speed is
exactly why it's so loud."* Tie film speed subtly to scroll.

**3 — Exploded view (the core beat).** The camera **breaks apart** — each part floats to its
own position with a thin leader line to a label + spec, revealed one at a time on scroll:
carbon-fiber body, film magazine ("~2.5–3 min per load"), the LCD screen (render the live
readout), reflex viewfinder + video tap. Hovering a floating part highlights it, dims the
rest, and pops its spec.

**4 — The noise problem & the blimp.** The reassembled camera lowers into the coffin-like
**blimp**. Copy: *"Even quieter than before, it was still too loud for dialogue, so IMAX
built a soundproof housing — the 'blimp.' Fully rigged, the system weighs 300–400 lb and
needs steel-plated dollies."* Show the scale/weight.

**5 — The mirror periscope.** The **twin-mirror arm** mounts beside the lens; animate a
sightline bouncing through the mirrors. Copy: *"The blimp was so wide it blocked the actors'
eyelines. On tight two-shots, Nolan and cinematographer Hoyte van Hoytema mounted a
double-mirror periscope so the actors could hold eye contact through reflections — with the
huge camera between them."*

**6 — The making-of.** A quiet, cinematic full-bleed beat. Copy (state plainly): *"Nolan
challenged IMAX to build a camera that could shoot an entire feature — dialogue and all.
They delivered."* Pull-quote, **Nolan verbatim:** *"If ever there were a story where you want
to do the whole thing on IMAX, this is it."* Three stat callouts, animated count-up:
**2,000,000+ feet of film shot · 6+ countries · first feature shot entirely on IMAX.**

## 7 — THE FINALE: shoot the Odyssey (the interactive payoff)
The camera reassembles and **turns toward a live Odyssey scene that you build procedurally
in 3D code** — not video, not trailer footage, a real-time vignette you generate from
scratch. A moonlit sea with Odysseus' galley against a low horizon works well: it gives
clear foreground/background depth so the focus-pull and the format toggle actually read.
Make it atmospheric and convincing, but **keep the camera the star** — the scene is the
stage it films, so it needs real depth and a clear Odyssey subject, not a second photoreal
simulation competing with the camera for detail. Now the visitor **operates the camera:**
- **Rack focus** — pull focus between foreground and the ship/horizon, with real bokeh.
- **Frame the shot** — pan/tilt the camera to compose; a subtle reticle + level.
- **Format toggle — IMAX 15/70 vs standard** — a switch that **changes the frame you're
  capturing**: the giant near-square IMAX frame vs a cropped standard frame, side by side or
  overlaid, so the visitor *sees and feels* why the format matters (how much more of the
  scene the IMAX frame holds). Show a live "viewfinder" of what the camera sees.
- Small authentic touches: the REC tally lights, the LCD ticks film remaining as you
  "roll," a shutter/film-running sound (Web Audio, synthesized).
End card: **"THE KEIGHLEY."** and a quiet memorial line: *"Named for David Keighley — five
decades at IMAX, post-production on over 500 films."*

## Design system
- **Palette:** near-black (#0a0a0a), bone white (#f4f1ea) text, one warm **film-amber**
  accent (#e8a33d) for leader lines/highlights, brushed metallic greys for the camera.
- **Type:** oversized condensed grotesque display headlines, clean sans body, big scale
  contrast.
- **Motion:** scroll-scrubbed and eased (disassembly maps to scroll; scrubbing up
  reassembles), gentle inertia, nothing abrupt. Thin scroll-progress / film-strip indicator.
- **Copy rules:** factual and plainly stated. No marketing adjectives, no jokes.

## Technical + runtime
Native ES modules, no build step. Fully responsive (rework the exploded layout + the finale
controls for mobile). Respect `prefers-reduced-motion` (present parts statically, disable
scrub). WebGL/WebGPU detection with a graceful message, resize, capped DPR, hidden-tab
pause. Smooth 60fps — throttle heavy work, LOD the camera when zoomed out. No generic cards,
stock imagery, or glassmorphism.

## Standards & iteration — do not stop early
Judged first on how photoreal the camera looks and how satisfying the shoot-the-scene finale
feels. **Do not call it done until the camera clears the exact-replica realism bar.** After
building, **render it, screenshot your own output, and inspect the camera in a close-up
orbit** — if it reads like a gray box, if the carbon fiber/lens/metal don't look real, if
the edges are razor-sharp CG, fix it and go again. Minimum **three full
self-review-and-improve passes**, more if needed. No placeholders, no invented APIs, no
console errors, no hidden fallback rendering. Return complete, directly runnable code and
brief launch instructions.

# Build Prompt — Odysseus and the Cyclops

A single build. A real, playable 3D game of Odysseus' escape from the cave of Polyphemus
the Cyclops, from *The Odyssey*. Two phases, in order: **blind** the passed-out giant with a
burning stake, then **escape** the cave clinging to the underbelly of a ram while the
blinded Cyclops gropes for you. It has to look like a **2026 AAA game** and actually be
playable and winnable. Everything is generated in code.

---

You are a world-class real-time graphics engineer AND game developer. Build a
production-quality, fully playable 3D game using **WebGPU via Three.js (WebGPURenderer +
TSL)**, native ES modules, no build step. Build all geometry and materials procedurally in
code — no imported 3D models, no image textures, no HDRIs. You MAY use open-source
libraries for the hard plumbing: a physics engine (`@dimforge/rapier3d` or `cannon-es`),
post-processing passes, and `lil-gui`. But you build the Cyclops, the cave, the rams, the
stake, and every material from math.

## The game — two phases

**Setting:** the torch- and fire-lit cave of Polyphemus. A massive Cyclops, a flock of
rams, the great fire, and the sharpened olive-wood stake.

### Phase 1 — Blind the Cyclops
Polyphemus is passed out drunk on the wine Odysseus gave him.
- **Heat the stake** in the fire: a charge mechanic — the tip glows wood-brown → red →
  white-hot and casts its own growing light. Too cold and the thrust fails; hold too long
  and the Cyclops stirs toward waking.
- **Aim at his single eye and THRUST** (press-and-hold to heat + aim, release to drive it
  in). Model the stake as a real physics object with weight and momentum.
- **Feedback + states:** sparks, a bright flash, the Cyclops roars and rears up, the eye
  goes dark. Clean win/fail: too early = not hot enough (bounces off); too slow = he wakes
  = game over. Success flows straight into Phase 2.

### Phase 2 — Escape under the rams
Now blind and enraged, Polyphemus feels his way to the cave mouth and **gropes the BACK of
every ram** with his huge hands to catch anyone riding out.
- **Cling to the UNDERBELLY of a ram** — the trick from the myth: he feels the top, never
  underneath.
- Move the flock toward the cave mouth; let the player **switch rams** and **time their
  movement** so they're never under a hand that's sweeping their lane.
- His hands sweep the rams' backs with real reach and readable timing (clear tells). Get
  felt = caught = fail. Reach the daylight at the cave mouth = **win**.

## Realism bar — this is the whole test
- **The Cyclops must be a believable, properly-proportioned GIANT** — real head with one
  eye, torso, arms, legs, huge hands, PBR skin, correct scale against the rams and the cave,
  simple believable animation (sleeping breath, the rear-up, the blind groping). A
  **stick-figure or featureless blob is a fail**, same bar as the ship.
- **Fire-lit atmosphere:** the great fire + torches as physically-correct lights,
  noise-driven flame flicker, **volumetric light shafts / god rays**, emissive flames with
  bloom, the **white-hot stake casting its own moving light**, deep shadow, depth-based haze,
  drifting embers/dust motes.
- **PBR everything:** FBM / triplanar **stone** for the cave walls and floor, procedural
  **wool** on the rams, **wood-grain** on the stake, wet/greasy sheen where it belongs,
  ambient occlusion in every crevice.
- **Lighting + render pipeline (all named, all required):** IBL via **PMREM** (dim cave
  ambient), **cascaded shadow maps**, **SSAO**, **SSR** where useful, **ACES** tone mapping,
  **bloom**, **depth-of-field** on the cinematic beats, correct linear/sRGB color management.
- **Physics:** real rigid-body physics for the stake, the rams, and collisions (use the
  physics lib). **Continuous / swept collision** so fast motion doesn't tunnel.

## Feel & controls (make it play like a real game)
- **Phase 1:** press-and-hold to heat + aim, release to thrust; a subtle heat gauge; camera
  pushes in on the eye with shake on impact and a brief slow-mo on the hit.
- **Phase 2:** move/steer the ram, switch rams, a tension meter for how close a hand is;
  under-belly / over-the-shoulder camera.
- Clear HUD, win and lose screens, quick retry. **Web Audio (synthesized only):** fire
  crackle, the Cyclops' breathing and roar, the stake sizzle, hooves — no imported audio.
- A live **FPS** readout and a difficulty / assist toggle.

## Runtime handling (required)
WebGPU detection with a graceful message, loading and failure states, resize, touch +
keyboard input, capped DPR, hidden-tab pause, `prefers-reduced-motion`, accessibility, and
performance safeguards (LOD / throttling to hold a smooth frame rate).

## Standards & iteration — do not stop early
Judged on how real it looks AND how it actually plays. **Do not call it done until the
Cyclops, the cave, and both phases clear the realism bar and the game is genuinely playable
and winnable end to end.** After building, render it, screenshot your own output, and
inspect it — the giant in close-up, the fire lighting, both phases played through. If the
Cyclops reads flat, if the cave looks like noise, if a phase isn't actually playable — fix
it and go again. Minimum **three full self-review-and-improve passes**, more if needed. No
placeholders, no invented APIs, no console errors, no hidden fallback rendering.

## Deliverable
Complete, directly runnable code (index.html + JS modules + any pinned library imports) plus
brief launch instructions. It must run at a smooth frame rate, look like a modern game, and
be fully playable and winnable.

Prompt coming.

Prompt coming.