Jelly Slime

Build **"Jelly Slime"**: a real-time, interactive 3D **cute little slime made of glowing lime jelly, full of rising bubbles, with a tiny candy skull floating inside it**, sitting on a cozy Halloween table at night. People **poke** it, **stretch** it into gooey strings, **pick it up**, **slice** it with a swipe so every piece becomes a **mini slime with its own eyes**, **push the pieces together** so they **merge** back with a gloop, **feed it gumballs** that bob inside it and change its colour, **splat it on the window**, **tickle** it and watch it melt into a sleepy puddle, with **synthesised sound**, as ONE self-contained HTML file rendered with **WebGPU (WGSL)** and an automatic **WebGL2** fallback.

**This is part of a series called Jelly Monsters, and the most important thing is that it looks stunning.** Every frame should look like a high-end product photo of a gummy candy character: glowing, glossy, wobbly, adorable. Someone scrolling past a still frame should stop and want to touch it. Spend your effort on the look and the jelly feel first, features second.

**It must also be fun.** Every touch gets a reaction with personality: it flinches, giggles, gets grumpy, looks puzzled, shows off. This monster can be **cut and put back together**, and that is the gift: one swipe and it comes apart with glossy goo strings stretching between the pieces, every piece opens its own pair of eyes and becomes a tiny slime of its own, and pushed back together they find each other, reach out with goo bridges and merge into one with a gloop. Nothing is ever lost: whatever you do, it always comes back together. It should be **hypnotic**: something you keep slicing and merging just to watch the strings stretch and snap, the bubbles rise and the skull bob back to the middle, the way people watch slime videos for hours.

## Priorities

Build it in this order, and finish each tier properly before starting the next. A polished tier 1 beats a broken everything.

1. **Must be stunning:** the character (cute, readable, plush-toy proportions, a slime from its silhouette alone), the lime jelly material, the bubbles and the candy skull inside it, the jelly feel (the wobble, the ring-down after every move, the gooey stretch), slicing into pieces with goo strings, every piece a cute mini slime with eyes, merging back, the night table scene and its lighting, the base interactions (Poke, Stretch, Grab, idle life), the demo mode.
2. **Must work:** the special trick (Split into many minis, Merge, pushing pieces together, the minis' own life, coming back together by themselves), the collection, colour flavours, feeding gumballs, Lava lamp, Shake, Pose, Reset, sound, both renderers, the control card, the secret.
3. **Gags and polish:** marbled colours when two flavours merge, the window splat, the melt into a sleepy puddle, the slime trail on the table, bubbles popping out of a fresh cut, Tickle, the collection's reactions, soft fog near the table, candle flicker reflected in the jelly and the eyes, slow motion, Cinema mode extras.

Never ship a feature half-working: if something from tier 3 can't be done well, leave it out cleanly.

## Deliverable

- One self-contained `.html` file with all JavaScript, WGSL, GLSL and CSS inline. Start it with `<!doctype html>`, `<meta charset="utf-8">` and a viewport meta.
- **No external requests of any kind**: no libraries, CDNs, web fonts, images, textures or audio files. Generate everything procedurally in code (sound included). Use system font stacks.
- It must run inside a sandboxed iframe (`sandbox="allow-scripts allow-pointer-lock"`). Do not use `localStorage`, cookies, `alert`, pop-ups or top-level navigation, and wrap any storage access in `try/catch`.
- This must be a live simulation, not a video, a pre-baked animation or a 2D fake.
- **Test hook:** if the URL has `?test=1`, expose `window.__toy` (no visible change) with `setTool(name)`, `poke(x, y, strength)`, `drag(x0, y0, x1, y1, ms)` (through the same code path as a real pointer drag with the current tool, in canvas pixels), `shake()`, `reset()`, `set(name, value)` for every slider, switch and flavour, the special-trick calls listed below, and `state()` returning `{ backend, tool, mode, volume, kinetic, busy, fps }` plus the special-trick fields listed below.

## The series look (same for every Jelly Monster)

**Character style**
- **A plush toy made of gummy candy.** Chunky, round, soft proportions: a big body, a big head (or one shape that is both), short stubby limbs if any. Nothing thin, spiky, sharp or realistic. No teeth beyond one tiny cute fang if the monster needs it.
- **Big glossy eyes** (each about a quarter of the face's width), glossy near-black candy with **one big soft white highlight** high up and a small second one, always visible whatever the lighting. Eyes **blink** now and then and **follow the pointer**. A **tiny smile**.
- **One or two strong colours** per flavour, plus a lighter face area. It must read at a glance as what it is (here: a slime) from its silhouette alone.
- **Every part is attached to the body.** Nothing hovers or floats detached around the character (the eyes sit on the jelly and move with it).

**The jelly**
- **Translucent all the way through**, never plastic: colour comes from absorption through the volume (Beer-Lambert), deep where it is thick and pale and bright at thin edges; the background is visible through it, bent by refraction (IOR about 1.35, like water). Small sharp wet highlights with a strong Fresnel sheen at grazing angles; no broad plastic clearcoat; tiny suspended air bubbles at different depths; faint internal grain.
- **It glows when backlit.** The moonlight from behind makes its edges and thin parts glow in its own colour. This is the signature look of the series.
- **It moves like jelly:** slow heavy jiggle (2 to 4 Hz), the top lags behind the base, it keeps its volume (squashed it bulges, pulled it thins), squashy dead bounces, never a rubbery boing.

**The scene**
- **A cozy Halloween tabletop at night**: a dark warm wooden table, three church candles of different heights on the left and back (real flickering flames, warm light that moves), a large window behind with a big pale moon and a deep blue-violet night sky, a little soft fog near the table surface. Two or three tiny props at the edges (a small pumpkin, scattered candy corn) that never compete with the character.
- **The collection:** the monsters from earlier days of the series sit in a row on a low wooden step at the back right of the table, as **tiny jelly figurines** about a fifth of the character's height, in the same jelly material (simpler shading is fine), softly out of focus, never in front of or overlapping the character. Each has its own big glossy eyes, blinks now and then and glances at the main monster when it does something big. They **react**: when the main monster does its big trick they hop and cheer, when it is shaken or dropped the table jolts and they wobble along, and when it poses they pose too. Tapping one with any tool makes it wobble, squeak and do a **tiny version of its own trick** (listed under The monster). They wobble on a cheap spring, no soft body of their own, and they never cost the main monster frame rate. In demo mode they sit still and only blink.
- **Lighting:** warm flickering candle key from the front-left, cool strong moon rim light from behind so the jelly glows at its edges, soft coloured shadows and a coloured light patch on the table where light passes through the jelly. Filmic tone mapping, gentle bloom on the candle flames and the jelly's highlights, a soft vignette.
- **Camera:** a slightly low three-quarter front view, close, like a food photo: the character fills about 55% of a square frame and looks into the camera. Orbit and zoom within limits; **no automatic follow cam that drifts**. The UI never covers the character on desktop.

## The monster (this monster)

- **A little slime in jelly**: a chubby **gumdrop-shaped blob** sitting on the table like a plush toy, facing the camera: rounder and taller than a puddle (about as tall as it is wide), with a soft rounded top that has a little **curl or peak** like whipped cream, and a base that **spreads a little onto the table** in a soft glossy skirt with two or three fat rounded **drips** frozen at the front, like a scoop of jelly just starting to melt. No limbs: it moves by squishing. Round and soft everywhere, nothing thin or spiky.
- **The jelly:** **lime**: bright juicy green where it is thick, glowing chartreuse at the thin parts (**the peak, the drips, the skirt, the edge of the silhouette**). The moon behind it turns its outline into a glowing green rim. A lighter, almost mint **face area** around the eyes. It is the wettest jelly in the series: extra glossy, every highlight sharp, a thin bright wet film along the skirt where it meets the table.
- **The inside (the wow factor):**
  - **A tiny candy skull** floats in the middle of the body: a round, cute **white sugar skull** (about a sixth of the body's height, chubby cheeks, big round eye sockets with little pink candy dots in them, a tiny stitched smile, never scary), seen through the green jelly, tinted and bent by it. It has weight and lags behind every move: it sloshes when the slime hops, bobs when it is poked, sinks a little when it melts, spins slowly when it is shaken, and always drifts back to the middle and settles with a little bob. It is a hard candy: it never deforms and is never cut.
  - **Bubbles:** dozens of **air bubbles** of different sizes (from tiny specks to a few as big as a pea) suspended at different depths, rising slowly, wobbling as they go. They collect under the top and every few seconds one **pops out of the surface** with a tiny sparkle and a "blip". Every move stirs them: a poke sends a swirl of them away from the finger, a landing shakes loose a stream from the bottom, Shake fills the slime with fizz that slowly rises and clears. A fresh cut lets a burst of bubbles escape from the cut face.
  - **Gumballs it ate** (see Special trick) bob inside it the same way, slowly dissolving into a coloured cloud.
  - Render the skull and gumballs into the opaque scene **before** the jelly pass, so the refraction bends them and the absorption tints them by the jelly's depth in front of them. The bubbles are small refractive spheres (or bright rim sprites) inside the thickness pass. None of it may ever look painted on the surface.
- **Eyes (this monster):** the series eyes, big glossy near-black candy domes with the big white highlight and the small second one, sitting high on the front of the body, wobbling with the jelly. Every piece it is cut into gets its own pair (see Special trick).
- **Face:** a tiny smile below the eyes and two soft pink cheek spots; when happy, a little round open mouth. It blows a small bubble from its mouth now and then.
- **The jelly feel (the most important part):** dense, heavy, slow, **gooey** jelly, like a big panna cotta that is a little bit melted, never rubber. Every move has **follow-through**: the peak lags behind the body and catches up with a wobble, the skirt keeps rippling after the body stops, the drips swing. Every landing ends in a **ring-down** you want to watch: a deep squash that spreads the skirt wide, a slow bulge back, two or three shrinking wobbles with the surface highlights sliding over the jelly, then perfectly still. Stretched, it pulls into **long gooey strands** that thin and sag before they snap back (never tear unless sliced).
- **How to build it (this monster):** because this monster splits and merges, use a **particle soft body** instead of a fixed lattice: about 800 to 1,500 particles in total, split between however many pieces exist, each piece held together by **shape matching** (meshless deformations: a rest shape per piece, recomputed when it splits or merges, with volume preservation) plus short-range cohesion between neighbouring particles, solved with the same fixed timestep. Draw the surface as **one smooth implicit surface over all particles** (screen-space fluid surface: sphere depth, then narrow-range or bilateral smoothing, normals from the smoothed depth, thickness from additive sprites; or a density grid raymarched or meshed each frame), so pieces, goo strings and merges are all the same smooth glossy jelly with no seams and no visible particle bumps. It must look as smooth and glossy as the series' other monsters at rest.
- **Moving around:** on the table it moves only by **squishy scooting**: it leans, its skirt stretches forward, the rest of the body follows like a caterpillar wave, leaving a faint **glossy slime trail** on the table that fades over a few seconds. Small hops when excited. It always comes back to its spot.
- **Idle life (this monster):** besides the base idle life, it blows a little bubble from its mouth that pops, lets one of its drips slide down and slurps it back up, flicks its peak like a hair flip, follows a rising bubble inside itself with its eyes, and wobbles to the candle flicker. After about 20 seconds without input it **melts**: it slowly sags into a wide glossy puddle with its eyes on top, sleepy, the skull settling flat inside, little bubbles rising and popping like snores. Any touch wakes it: it **pulls itself back up** with a gloopy slurp, the skull bobbing back to the middle, and gives a little shake.
- **Mood in the peak:** happy = peak up and curly; curious = peak bent like a question mark; grumpy = peak flat, body squashed low and wide, skirt pulled in; scared (after a drop) = it squishes as small and round as it can, eyes squeezed shut, then peeks.
- **The collection** (5 figurines, oldest on the left):
  - **Spider** (#1): a round teal gumdrop dome with a lighter mint face patch, two big eyes, eight short chubby aqua legs. Its trick: a rainbow fan on its back rises like a peacock spider's and it does a little side-to-side dance.
  - **Ghost** (#2): a milky white-blue glowing ghost with a scalloped skirt, hovering just above the step. Its trick: it puffs up and goes "boo" with a tiny O mouth, and the nearest candle flame flickers.
  - **Skeleton** (#3): an almost water-clear jelly figure sitting with its legs out, white candy bones visible inside (a round skull with the eyes in its sockets, a ribcage). Its trick: its bones rattle loose inside the jelly and click back into place one by one, skull last.
  - **Black cat** (#4): a glossy near-black cherry jelly kitten sitting upright, tail curled round its paws, glowing green eyes, its outline and ears glowing ruby, a few tiny star sparkles drifting inside it. Its trick: it crouches, wiggles its butt and does a tiny pounce on the spot, landing with a squash and a "mew".
  - **Bat** (#5): a chubby grape-violet jelly bat sitting upright, big ears glowing amethyst like little lanterns, wings folded round it like a cape, one tiny fang, lighter grape juice swirling inside. Its trick: it spreads its wings (they glow violet like stained glass), flaps once, flips upside down in a tiny somersault and lands back on its feet with a squash and an "eep".
- **Flavours** (round swatches): **Lime** (default: bright green body, chartreuse glow, mint face), **Blue Raspberry** (clear deep cyan-blue jelly, aqua glow), **Bubblegum** (pink jelly, hot-pink glow), **Orange Soda** (amber-orange jelly, golden glow, extra fizzy bubbles), **Clear** (water-clear jelly with a pale cyan glow: every bubble and the skull on full show). Every flavour keeps the pink cheeks and the white sugar skull, and every piece has its own flavour (see Special trick).

## Base interactions (same for every Jelly Monster)

A tool picker with **Poke**, **Stretch** and **Grab**. The default tool is Poke. A press that ends within 6 px and 450 ms counts as a tap. Right-drag or two fingers orbit the camera with any tool. Pointer events with **pointer capture**, mouse, pen and touch.

- **Poke:** a tap presses a deep rounded dent that springs back with a wobble rippling over the whole body; it **flinches** (eyes squeeze shut, body ducks), then shakes it off. Holding presses deeper and the jelly bulges around the finger. Poked many times in a row, it gets a little grumpy (frowns, turns away), then forgives you.
- **Stretch:** grab any point and pull: the jelly stretches out locally like taffy, thinning near the finger and bulging back at the body, and on release **snaps back** with a big satisfying wobble. Never tears, never moves the whole body rigidly. The further you pull, the bigger the snap.
- **Grab:** pick the whole monster up by the point you grabbed; it dangles and sways with weight, its eyes go wide; release to drop it (a squashy splat and wobble), or release during a fast drag to toss it a little way. It always ends up back in its spot, happy.
- **Tickle:** with Poke, small fast circles on the body (about three loops) start a giggle fit: it squirms, ripples run all over the jelly, its eyes squeeze into happy arcs and it wriggles away from the finger, then catches its breath.
- **Shake** (button and `S`): the whole monster jiggles hard for a second like a plate of jelly being shaken, then settles.
- **Pose** (button and `F`): the monster strikes a cute pose, a different one each time in turn (a wave, a wink, a little "ta-da" with its arms up, adapted to its shape), the figurines in the collection pose too, and a soft white camera flash fires: the frame then holds still for 1 second with all UI and the cursor hidden (a clean screenshot), and the UI fades back. Never during demo mode.
- **Idle life:** it breathes, blinks, follows the pointer with its eyes and body, and every few seconds does a small cute idle animation of its own. Never perfectly frozen.
- **Reset** (`R`): back to its spot, settled.
- **Physics:** a volumetric soft body (a lattice of about 500 to 1,500 cells, XPBD or shape matching with volume preservation) skinned to a smooth high-resolution surface, with a fixed timestep (about 1/120 s) and bounded substeps. Deformation clamped so it always reads as itself; back to exact rest within 2 to 3 seconds; no jitter at rest, no explosions, no creep, nothing passing through the table.

## Special trick (this monster)

- **Slice** (tool `4`): a quick swipe across the slime (any direction, start and end outside or on the body) leaves a thin glowing line in the air that fades, and **cuts the slime in two** along the plane the swipe draws through the scene (the plane through the camera rays at the swipe's start and end). The pieces really separate: each keeps the particles on its side, gets a new rest shape (rounded off over about half a second into a little gumdrop of its own, so a half never stays a flat half-dome) and slides apart a little from the cut. A swipe that misses does nothing; a slow drag with Slice draws the line without cutting until it crosses the body fast enough. Slicing a piece cuts that piece; one swipe can cut through several pieces at once.
- **Goo strings (the most satisfying thing in the toy):** whenever two pieces come apart (a slice, Grab pulling a piece away, Split), **glossy strings of goo** stretch between them: three to six strands of different thickness, attached to both cut faces, thinning in the middle as they stretch, **sagging** under their own weight, swinging, and **snapping** one by one when they get too long or too thin, each half recoiling into its piece with a little drip and a wobble of the piece. A slow pull makes long, thin, sagging strings; a fast swipe makes short strings that snap quickly. Build them as chains of small particles with distance constraints that break when overstretched, drawn by the same smooth surface as the body, so a string is part of the jelly, thick where it leaves the body and fine in the middle.
- **Mini slimes:** **every piece is a slime of its own**. A new piece **pops open a pair of eyes** in surprise (with a little "!" squeak), blinks, looks at the other pieces and at the pointer, and does everything the big slime does, scaled down: breathes, wobbles, scoots, flinches when poked, babbles in a higher voice the smaller it is, blows tiny bubbles. Eyes stay big and cute on small pieces (scale them down less than the body). Each piece takes its share of the bubbles; the **skull stays in whichever piece its centre falls in**, and that piece acts a little bossy (it wobbles its peak, the others follow it around). Up to **8 pieces**; a piece too small to cut (about an eighth of the full slime) just giggles and wobbles when sliced. Minis stay on the table, inside the frame and away from the collection, gently pushing each other aside, never overlapping. Grab, Stretch, Poke and Tickle work on each piece separately.
- **Merge:** push one piece into another (Grab it over, Poke-drag it, or toss it at another one): as soon as they touch they **stick**, a thick **goo bridge** forms between them and pulls them together, and they **merge with a gloop** into one bigger slime: the surface flows together seamlessly, the bubbles swirl, the rest shape is recomputed and the merged piece wobbles round into a gumdrop again and rings down. The smaller piece's eyes close happily and fade into the jelly as they merge; the bigger piece's eyes stay. The skull floats to the middle of whatever piece holds it. Merging two flavours leaves a **marbled swirl** of both colours that blends into an even mix over about 3 seconds.
- **Split** (big accent button and `X`, the big moment): a swipe-free party trick: the slime shivers, bulges in three or four places and **pops apart into 8 mini slimes** in a burst of goo strings and bubbles, the minis bouncing out across the table in a ring, landing with tiny squashes, then all opening their eyes at once and looking around. The collection cheers.
- **Merge all** (button and `G`): every mini hops toward the one with the skull, and they merge **one by one** in a cascade, each merge a gloop and a note higher, until the big slime is back. It shakes itself, burps a big bubble out of its top that pops into sparkles, and grins. The collection cheers.
- **Coming back together:** left alone for about 15 seconds while it is in pieces, the minis scoot toward each other on their own and merge back, the last one doing a little hop. The slime always ends up whole on its spot if you wait.
- **Feeding gumballs:** five glossy **gumballs** (one per flavour colour) sit in a little candy dish on the table front right. Tap one (or drag it with Grab onto a slime): the nearest piece scoots over, leans over it, **engulfs** it with a slurp and a gulp, and the gumball **bobs inside the jelly**, visible through it, slowly dissolving over about 10 seconds into a cloud of its colour that swirls through that piece, while the piece blends to that gumball's flavour over about 3 seconds. A new gumball rolls into the dish a moment later. Feeding pieces different flavours and merging them gives the marbled swirl.
- **Lava lamp** (switch, `A`): the slime slowly buds off one or two little slimes at a time (a bulge that pinches off with a goo string), they wander around, bump into each other, merge back and bud off again, in an endless, calm, varied loop, the bubbles rising through every piece and the skull drifting from piece to piece as they merge. Never more than five pieces at once; every so often everything merges back into the big slime for a few seconds. Works with Slow motion. This is the screensaver of the toy.
- **Window splat:** with Grab, toss a slime (or a mini) hard toward the window, or press **Splat** (`W`): it flies, **splats flat onto the glass** right in front of the moon, squished face and all, the moon shining through it so it **blazes green like stained glass**, then slowly **slides down** the glass leaving a glowing glossy trail that fades, peels off at the bottom and plops back onto the table with a ring-down, scooting back to its spot. It always stays inside the frame and never touches the collection.
- **Shake:** the base Shake, plus every piece fizzes full of stirred bubbles and the skull spins; if it is in pieces, they jiggle toward each other and some merge on the way.
- **Test hook:** `slice(x0, y0, x1, y1)` (a swipe in canvas pixels), `split()`, `mergeAll()`, `merge(i, j)` (push piece `i` into piece `j`), `pull(i, x, y)` (drag piece `i` to canvas pixel `x, y` with Grab, then release), `feed(i, piece)` (gumball `i`, 0 to 4, to piece `piece`), `lavaLamp(on)`, `splat()`, `melt()`, `skullTap()`, `figurine(i)` (tap collection figurine `i`, 0 = oldest), `pose()`, `tickle()`; `state()` adds `pieces` (number of pieces), `sizes` (each piece's share of the full slime, 0 to 1), `skullIn` (the piece holding the skull), `strings` (active goo strands), `merging`, `bubbles` (0 = calm, 1 = fizzing hard), `lavaLamp`, `splatted`, `melted`, `posing`, `secret` and `mood`.

## Secret (this monster)

- **Who lives in there?** When the slime is whole and at rest, tap the **skull inside it** three times gently with Poke (a tap whose ray passes through the skull). The skull **wakes up**: two tiny glowing eyes light up in its sockets, it looks around inside the jelly, notices you and **waves** a tiny candy hand from inside. Then the slime blows a big glossy **bubble** out of its top with the skull inside it: the bubble floats up a little, wobbling like a soap bubble, the skull waving from inside, until it pops into green sparkles and the skull plops back into the slime with a bloop and a ripple, eyes closing sleepily. A small badge: "Someone lives in there." Never hint at it in the UI.

## Sound

Every action has a **synthesised sound**, generated live with the **Web Audio API** (oscillators, filtered noise, envelopes). **No audio files, no samples.** Soft, cute, wet: squishes, bloops and creaks for the jelly; a short squeak for the flinch; a rising wet stretch and a satisfying snap-back bloop for Stretch; a splat for a drop; a jiggly rattle for Shake; a camera shutter click for Pose; and for this monster: a clean, wet **slice** ("shlick", a short bright filtered-noise sweep with a soft squelch under it), the **goo strings** (a stretchy, sticky creak rising as they thin, and a tiny wet "thwip" as each one snaps: the most important sound with the merge), the **merge** (a deep, round, satisfying "gloop" with a short slurp before it), the minis' **babble** (tiny high chirps and coos, higher the smaller the piece, each mini with its own little voice), a surprised "!" squeak when a new piece opens its eyes, **bubble blips** as bubbles pop out of the surface (soft, pitched on a pentatonic scale so the fizz sounds like a little music box), the Merge all cascade (each merge a note higher, ending on a happy chord and a big burp-bubble pop), a slurp and gulp for a gumball and a syrupy gurgle as it dissolves, the window **splat** and a squeaky wet slide down the glass, a sleepy sigh and bubbly snores when it melts, a gloopy slurp when it pulls itself back up, a giggle-squeak for Tickle, a tiny bony rattle and a music-box arpeggio for the secret, and a tiny high squeak plus a mini version of its own sound for each collection figurine.

Rules: create the `AudioContext` only on the first user gesture and never before; resume a `suspended` context on interaction; master gain into a compressor, no clipping; cap at about 16 voices; wrap every audio call in `try/catch`. Sound on by default; a **speaker button** and `M` mute it.

## Rendering (WebGPU with a WebGL2 fallback)

**WebGPU (WGSL) when available, with an automatic WebGL2 fallback that looks the same.** Detect at start; if WebGPU is missing, or adapter or device creation fails, use WebGL2. **If the WebGPU device is lost at any time (`device.lost`), switch to WebGL2 on the spot and keep rendering**: the toy must never end up on a blank screen. No libraries: write both paths yourself, sharing the scene data and the simulation. Show which one runs in the status pill.

- **Jelly:** back faces into a thickness buffer, then front faces, absorption from the distance light travels through the jelly, screen-space refraction of the scene behind (IOR about 1.35, offset scaled by thickness), a wrap-around subsurface term for the backlit glow, wet specular with Schlick Fresnel and a tight highlight, internal grain and bubbles. Opaque shading with an alpha value is not acceptable.
- **Eyes:** glossy dark candy domes with the white highlight painted in plus a real specular glint, so they always read as big cute eyes.
- **Scene:** candle flames as flickering additive sprites with a warm point light each; the moon as a soft disc with a rim light; soft shadows; table wood grain procedural; fog as a few soft sprites near the table.
- Preallocate all buffers and build every pipeline at start; never create shaders, pipelines or geometry during interaction. DPR capped at 2. An automatic **quality scaler** lowers resolution and bloom before it ever touches the jelly feel. It must stay smooth on a mid-range phone.
- Only if neither WebGPU nor WebGL2 exists, show a clear, well-designed message.

## Interface

A dark, cozy interface that stays out of the way; the monster is the hero and UI never covers it.

**Top left:** small caps `POKEABLE · JELLY MONSTERS 6 / 15`, a large italic serif heading on two lines: *Jelly* / *Slime.*, and caption lines "Cut it." / "Stretch it." / "Put it back together."

**Top right:** a live status dot with `WEBGPU · LIVE` or `WEBGL2 · LIVE`, a **speaker icon button** (`ON` / `MUTED`), and `PAUSED` when paused.

**Right panel: control card "Slime"**, a floating card about 240px wide with 20px corners, dark charcoal with a hint of green, soft shadow, no hairlines, plain system sans, bold sentence-case labels, and an accent colour taken from the active flavour's glow. Tools as rounded tiles with small drawn icons and key numbers (`1` Poke, `2` Stretch, `3` Grab, `4` Slice), the special-trick controls as a big accent button (**Split**) and a switch (**Lava lamp**), **Merge all**, **Splat**, **Shake**, **Pose** and **Reset** as chips, flavours as round swatches (they recolour every piece), sliders for **Softness**, **Wobble** and **Sound** (6px rounded track, round white thumb, monospace value chips), switches for **Slow motion** and **Cinema**, and **Pause / Resume** as a full-width pill. Collapsible to a small button; a bottom sheet on narrow screens.

**Bottom left:** a one-line hint per tool ("Tap to poke. Tap a gumball to feed it.", "Grab and pull. Watch it get gooey.", "Pick a piece up. Push pieces together.", "Swipe through it to cut.").

**Cinema** (`C`) hides all UI and the cursor; a tap without drag, `C` or Esc brings it back. Respect `prefers-reduced-motion` for UI transitions and camera moves; the jelly still responds fully. Keys: `1` to `4` tools, `X` Split, `G` Merge all, `W` Splat, `A` Lava lamp, `S` Shake, `F` Pose, `P` next flavour, `C` Cinema, `M` mute, Space pause, `R` reset, `0` reset view.

## Demo mode (required)

If the URL has `?demo=1`, auto-play a 4-second loop with no user input: the object drops in, wobbles, gets poked or sliced once, then settles.

For this toy that means:
- **Hide all UI** and the cursor. One fixed quality preset (no quality scaler), the default flavour, the fixed default camera.
- **Never create an `AudioContext`**, play nothing.
- Deterministic, no randomness; restart every 4.0 s of real time from the identical state; drive the simulation from real elapsed time with the fixed timestep so the loop lasts 4 s at any frame rate.
- Timeline:
  - **0.0 to 0.6 s:** the slime drops onto its spot, lands with a deep squash that spreads its skirt wide and rings out, bubbles shaken loose and the skull bobbing inside.
  - **0.7 to 0.9 s:** an invisible finger pokes its cheek: it flinches, eyes squeezed shut, and shakes it off.
  - **1.0 to 1.2 s:** a thin glowing slice line sweeps down through the middle, slightly diagonal: it **splits in two**, a burst of bubbles escaping the cut.
  - **1.2 to 2.2 s:** **the goo strings**: the halves slide apart, glossy strands stretching between them, thinning and sagging (fullest around 1.7 s), the right half popping open a new pair of eyes in surprise, the skull bobbing in the left half; the strands snap one by one with little drips. The most striking moment.
  - **2.2 to 3.0 s:** the halves look at each other, scoot together, touch, a goo bridge pulls them in and they **merge** with a gloop, the bubbles swirling.
  - **3.0 to 3.5 s:** whole again, it shakes itself and burps a bubble out of its top that pops into sparkles.
  - **3.5 to 4.0 s:** it rounds back into its gumdrop shape and settles, the skull drifting to the middle, ready for the loop to start again.
- Start moving within 1 s. It is recorded in a slow software renderer: **the green jelly, the goo strings, the bubbles, the skull inside and the new pair of eyes must read clearly at 15 fps**.
- Support `?demo=1&t=<seconds>` to freeze the demo at that time (for screenshots).

## Before you finish

Self-check against this list and fix anything that fails:
- **The scroll-stop test:** take still frames at rest, mid-stretch, right after a slice with the goo strings at their longest, with 8 minis on the table, mid-merge with a goo bridge, splatted on the window in front of the moon, with a gumball dissolving inside, in a marbled two-flavour swirl, melted into a puddle, during the secret and in every flavour. Each must look like a premium photo of a glowing gummy candy character: cute, glossy, translucent, backlit, with readable eyes, the collection reading as small background figurines that never steal the eye. The surface must be **one smooth glossy jelly**: never bumpy, grainy or made of visible balls, never seams between pieces or along the strings. The skull and bubbles must read as things **inside** the jelly, never painted on its surface. If any frame looks like plastic, glass, a flat cartoon, a pile of spheres or something creepy, fix the look before anything else.
- **The cute test:** from the default view it reads instantly as a friendly chubby little slime with big shiny eyes; every mini is cute too; the skull is a sweet candy, never scary; nothing sharp, no teeth, no gore at the cut (a cut face is just clean glossy jelly).
- Poke every part 50 times fast, stretch from every side as far as possible, grab and toss every piece, slice it into 8 and keep slicing, Split and Merge all ten times in a row, Split then Shake, merge pieces in every order, feed every gumball to different pieces, switch flavours mid-merge, splat it on the window from every angle, leave Lava lamp on for five minutes: never an exploded or inverted body, jitter at rest, particles leaking or drifting free, a piece lost or stuck outside the frame, more than 8 pieces, a piece with no eyes or two pairs, the skull outside the jelly or cut, strings that never snap, pieces overlapping each other or the collection, a part through the table, or a crash. After every test it ends up whole (or in pieces that merge back by themselves) on its spot, slime-shaped and settled.
- Every tool, button, switch, slider and key; slicing in every direction; the goo strings; Split; Merge all; pushing pieces together; coming back together by itself; feeding; the marbled merge; Lava lamp; the window splat; melting and waking it; tapping each figurine; Pose several times in a row; Tickle; pause and resume; Slow motion; Cinema; resizing to phone width with touch.
- **The fun test:** slice, merge, stretch, feed and splat it for a minute. Every action gets its own visible reaction and sound, every string and wobble is worth watching to the end, and it never feels like a static model being deformed. **The hypnosis test:** watch Lava lamp for a minute and slice it in half and merge it back ten times watching the strings: you should not want to stop.
- The secret by hand.
- Sound: every action has its effect, nothing before the first gesture, mute works, no clipping.
- `?demo=1` matches the timeline, loops cleanly, shows no UI and plays no sound; `?demo=1&t=1.7` freezes with the two halves apart and the goo strings at their fullest, the new eyes open.
- No console errors or WebGPU validation errors on WebGPU AND on the WebGL2 path, the device-lost fallback works (simulate it with `device.destroy()`), and it stays smooth on a mid-range phone.

Make it the most beautiful jelly toy you can. The jelly feel comes first: it should be the slime people keep cutting in half just to watch the goo strings stretch and snap, and merging back just to hear the gloop.