Pinned Tweet
$0.21 vs $7.88 for a tiny ice rink
MiniMax M3.1-Flash vs GPT-6 Astra
MiniMax takes this one for me. Look at the nighttime lighting: warm lamps, shadows across the ice, glowing windows, and all those little details. The whole scene feels more alive
And all that for just 21 cents - almost 38 times cheaper than Astra
I’m picking MiniMax for both quality and price. What about you?
An oil platform, wind turbines and a storm - all inside one jelly cube 🌊
Claude Opus 5.5 vs. GPT-6 Astra - who built the better offshore world?
Claude grabs your attention with the water physics, rolling waves and surface foam. Astra makes you look beneath the water - the detailed seabed and underwater structures turn its jelly cube into a little world you want to explore from every angle
API costs:
Claude Opus 5.5 - 14.20$
GPT-6 Astra - 12.09$
Who won this round?
PROMPT
Build "Offshore Jelly" — a single-file interactive WebGPU diorama in the "Material Studies" series: a stretch of North Sea cut out as a cube of translucent jelly, sitting on a studio floor. Everything is procedural (no external assets, no network), one HTML file with inline JS/WGSL.
THE BLOCK
- A wobbly jelly cube you can grab by its sides and tip; it springs back. Sliders: firmness, damping, wind (0–20 m/s).
- Inside: a shallow-water simulation for the sea surface (waves, wakes, foam, whitecaps), seabed with sand ripples, scour rocks, kelp, boulders, starfish, crabs, urchins, a pipeline, cables and a small wreck. Caustics on the seabed. Dragging the water stirs up waves.
- Waves come from the wind: several wave trains whose height grows with wind speed.
THE SCENE
- A production platform on a four-legged steel jacket (braces, risers, conductors, boat landing, marine growth below the waterline): main and cellar decks, process module, derrick, living quarters, lifeboats, a pedestal crane with a laydown area, a flare boom with a flickering flame and smoke.
- An octagonal helideck with an H, a net, perimeter lights and a windsock.
- Five offshore wind turbines on monopiles: transition piece with yellow platform, boat landing ladder, davit, tower, nacelle, three-blade rotors with red tips, blinking red aviation lights. Rotor speed and power output (MW) follow the wind.
- A rocky skerry with a lighthouse whose beam turns; seals haul out on it.
WHAT HAPPENS
- Supply run: a platform supply vessel comes in from standby, holds station next to the jacket on dynamic positioning (thruster foam), and the crane does four lifts — containers swing on the hook, are set down on the platform and back-loaded onto the boat's deck. Then she sails back to standby.
- Helicopter: flies in from the west, turns into the wind, lands on the helideck; a deck officer walks out; passengers get off. A second press sends it away (spin-up, lift, outbound). Rotor and tail rotor spin, downwash flattens the water.
- Crew boat: a small catamaran sails out to a turbine, pushes its bow onto the boat landing, and technicians climb the ladder onto the platform. Next time she picks them up and brings them home.
- Storm: the wind builds to a gale, waves get big with whitecaps and spray, rain falls, the room darkens, lightning strikes blades, the lighthouse, the derrick or the sea with a flash and thunder. Above cut-out the turbines feather their blades and stop (0 MW); the helicopter is grounded. Then it eases and the turbines restart.
LIFE
- Schools of fish around the jacket and wrecks, gulls that perch on railings and take off on the horn, gannets that plunge-dive for fish, a pod of porpoises, seals, moon jellyfish, crew walking the decks.
CONTROLS & UI
- Buttons: Supply run, Helicopter (take-off when landed), Crew boat, Storm. Space = ship's horn. Tapping a turbine switches it on/off, tapping the supply boat or helideck calls them. Orbit by drag, zoom by wheel/pinch.
- Tallies: Power (MW), Lifts, Flights; status lines for the supply boat, helicopter and crew boat.
- Flavours (jelly colour palettes): North Sea, Curaçao, Blackcurrant.
- Sounds are synthesised with WebAudio and only play for events (horn, winch, set-down, bump, rotor, thunder, rain) — no constant background ambience. Sound toggle and pause.
- Mobile: a bottom sheet with the controls, touch orbit and pinch zoom. Clean fallback message when WebGPU is unavailable.
- Copy in English: "Offshore Jelly. A wind farm and a platform working a stretch of North Sea, set in a block of jelly." — "Call in the supply boat. Fly the crew out. Brew up a storm."
check it out
GPT-6 Astra offshore-jelly.vercel.app
Claude Opus 5.5 claude.ai/artifact/72XvmkxAe…
Claude Opus 5.5 built this little beach volleyball world for $10.43 🏐
A tiny 3D beach with a pixel-art look: players running around the court, waves rolling onto the sand, palm trees and a little beach hut
You can zoom in, rotate the scene, change the wind and switch between day, sunset and night. My favorite part is the evening atmosphere - the lights come on, the campfire glows, and the whole beach feels different.
18 seconds of a tiny summer escape
What do you think of the result for $10.43?
PROMPT:
Build a single-page web toy called "Beach Two": a real-time 3D scene rendered as pixel art — a beach volleyball court on a floating island with the sea in front. three.js r160 via import map (jsDelivr), English UI, original design only (no real brands).
RENDERING PIPELINE
- Orthographic camera at an isometric angle (≈31° down, azimuth π/4, rotatable in 90° steps with easing; drag sideways or buttons; wheel/pinch zoom 0.7–2.8). Fit the island outline plus palm tops into the screen area left free by the UI; snap the camera so the world origin lands on a whole art pixel.
- Render into a small half-float WebGLRenderTarget (nearest filtering, depth texture), ~480×300 art pixels at pixel size 3, no anti-aliasing.
- A mirrored reflection pass first (scene.scale.y = −1 about the water plane, hiding the sand, water and particles) into its own target; the water samples it in screen space.
- Post pass: texelFetch whole-pixel upscale, depth outlines (neighbour > 0.5 m nearer → darken ×0.5), nearest-of-~65 palette colours in OKLab (L weighted ×1.35), optional 4×4 Bayer dither, empty depth = page background. "Raw 3D" toggle shows the full-res MSAA render. Pixel size slider 2–6, palette/dither/outline checkboxes.
- Palette: foam whites and greys, sand from dry to wet, sea from shallow turquoise to deep blue, sky blues and night, sunset peach/coral/rose/violet, palm greens, team coral and teal, yellow/blue accents, skin and wood, lamp and fire yellows.
WORLD
- Island 33×26 m with rounded corners, cut like a cake: a sand heightfield grid pressed into the outline (dunes at the back, flat court, slope under the sea along a gently curving shoreline), coloured face by face with sand speckle and a wet band, smooth analytic normals. The cut side shows sand bands, and where the sea is a wall of water in depth layers; soil and rock below.
- Sea: a grid of waves updated every frame (rolling swells, chop, shoaling near shore), vertex colours by depth, foam where crests break in the shallows and along the swash line; shader mixes its own tinted colour with the mirrored beach (slight wobble) and adds sun/moon glints from facet normals. Buoys on a rope bob on the waves.
- Court 16×8 m with blue straps, net (alpha grid texture, white tapes, red-white antennae, padded posts, guy ropes).
- Palms with ringed curved trunks and drooping fronds swaying with the wind; dune grass; a boardwalk; a snack kiosk with striped awning, sign, lit hatch at night, surfboards, cooler and stools; benches; a beach shower; a lifeguard tower with a wind flag; striped umbrellas, towels, a deck chair, a sandcastle, a rowboat, a fire pit with logs; string lights on posts; two floodlights.
- Footprints and ball marks as instanced dents in the sand that fade back over time.
PEOPLE
- Box rigs (~18 boxes) posed every frame with two-bone IK: run on sand, ready stance, bump platform, setting window, spike (cock–whip–follow-through, airborne), serve with toss, block with arms up, sprawling dive, celebrate and high five, hold/throw the ball. Players have caps, glasses, buns.
- Beachgoers: one sunbathing on a towel, one in a deck chair, two standing who clap/cheer on points, a kid patting a sandcastle, two sitting by the fire. Gulls circle, flapping or gliding, casting shadows.
GAME (rally scoring to 15, win by 2, sets counted)
- Ball physics in substeps: gravity, quadratic air drag, wind with gusts, float-serve wobble; net crossing → tape dribble-over or drops into the net; posts; antennae fault; landing on sand with a puff and short roll; floating and drifting in the sea.
- AI: predict the ball's real flight; for the side it comes down on, pick who can reach the contact height in time (zones break ties); types pass/dig, set (or bump set), attack (or free ball), dive when slightly late; leave balls clearly going out; occasional "seam" where both leave the serve.
- Shot aiming by iterative simulation (lob to an apex, or a drive at a speed with bisection on launch angle plus drift correction), allowing for ~70% of the wind. Pass errors grow with incoming speed, wind and lateness; shanks on hard balls.
- Attack: run-up timed so the jump peaks at contact; candidate targets (line/cross deep, cut shots, pokes) scored by distance from the defender and block, with a taste for spiking; net-clearance check, small chances of long or net errors.
- Defence: one blocker jumps with the hitter in his lane (stuff, soft touch counting as first touch, or off the fingers), one deep defender shading away from the block.
- Serves: lobbed floats or hard flat serves; small error rates. Between rallies the nearest player fetches the ball (anywhere, even in the sea), lobs it to the server, who walks to the line.
UI
- Lit pixel-font scoreboard (CORAL vs TEAL, set number, status, serve dots, sets won). Rail: Time (Day/Sunset/Night), Wind (Calm/Breeze/Gusty + live m/s), Attack style (Auto/Spike/Shots), New match, Pause, View. Click the sand to call where the next attack goes (marker X). Light/dark themes; stacked layout on phones; "How it's drawn" panel.
PROMPT:
Build "Pixel Ice Rink" — a single-file, real-time three.js (r160, ES module via import map from jsDelivr) page: an isometric diorama of a floating outdoor ice rink, rendered as crisp pixel art in the style of "3D rendered as pixel art". UI text in English.
RENDER PIPELINE
- Orthographic camera at ~31° elevation, azimuth 45° + 90° steps (animated turns, drag sideways or buttons), wheel/pinch zoom. Fit the whole floating slab into the free screen area (clear of the title, a top-centre scoreboard and a right control rail).
- Render the scene into a tiny target (screen / pixel size, ~480×300 on desktop) with no anti-aliasing. Snap the camera so the world origin lands on a whole pixel (static things never shimmer).
- Post pass on a full-screen quad:
- depth-based outlines: darken a pixel that stands >0.55 m in front of a neighbour;
- map every pixel to the nearest colour of a fixed ~49-colour winter palette in OKLab (snow/ice greys, ice blues, reds, lamplight/wood/skin, pines, dusk peach/rose/mauve/lilac, brass/ochre);
- optional light 4×4 Bayer dither;
- upscale with texelFetch so each art pixel is an exact block of device pixels. The background (depth = 1) is the page colour.
- Hard sun shadows (BasicShadowMap, 2048). Lambert flat-shaded low-poly materials.
- Planar ice reflection: render the scene mirrored (scene.scale.y = -1 about the ice plane, ground, ice, particles and lamp posts hidden) into a second target. Sample it in the ice shader at gl_FragCoord. Gloss = small base + extra where the ice is wet, reduced where it is worn.
- A "Raw 3D" mode renders the same scene at full resolution with MSAA, for comparison.
SCENE
- A floating slab of snow over earth over rock, each extruded from a ragged rounded rectangle.
- A 24×12 m rink with 3 m corners: white boards with a yellow kick plate and red cap, built as band segments with gaps for two bench doors and a double resurfacer gate (hinged doors that swing open).
- Ice markings painted texel-by-texel into a 10 px/m canvas: red centre and goal lines, blue lines, circles, face-off dots, creases.
- Red-post goals with alpha-tested grid nets; players' benches; a lit scoreboard drawn with 3×5 pixel digits.
- A log warming hut with lit windows and chimney smoke; a garage for the resurfacer; lamp posts with point lights; string lights at night.
- Snowy stacked-cone pines, snowbanks, a snowman.
PLAYERS — procedural rigs of ~16 boxes
- Placed every frame from heading, lean, crouch and turn roll. Two-bone IK for the legs (skating stride with push-out and toe-out, gliding, sideways hockey stop) and for the arms holding a stick.
- Stick poses: carry/stickhandle, slap-shot wind-up and strike, pass sweep, celebration with stick raised.
- Goalies: pads, blocker and glove, crease positioning, butterfly drop on incoming shots.
GAME
- Two-on-two pick-up hockey plus goalies. Steering with arrival, separation and board/net avoidance; hockey stops when reversing hard.
- Carrier AI weaves to the slot, shoots when the lane is open, passes when pressured. Defenders pressure goal-side and poke-check; the nearest skater chases a loose puck.
- Puck physics with substeps: friction, board bounces, posts, solid nets with goal detection through the mouth, goalie saves (deflect or catch and play out), blocks by skates.
- Face-offs, goal celebrations, score, shots and a game clock on the scoreboard. Clicking the ice drops a puck.
ICE WEAR
- An RG DataTexture over the rink (20 px/m). Blades write scratches as they glide; stops gouge wider marks and throw spray particles that settle as wear; falling snow settles too.
- "Resurface the ice": players skate off through the bench doors; the resurfacer drives out of its garage through the gate and does shrinking rounded-rectangle laps (swinging in front of the nets), wiping its swath and leaving wet, reflective ice that dries over time. Then the players return for a face-off. Show an "ice worn %" bar.
UI
- Pixel display font (Silkscreen) with a clean body font.
- Light and dark themes via tokens; the background is a near-white or near-black page.
- Controls: Day / Dusk / Night (lighting presets blended over ~1.6 s), Snow Off / Light / Heavy, Resurface, Drop a puck, Pause, New game, Turn left / right, Pixel art / Raw 3D, Pixel size slider, Palette / Dither / Outlines toggles.
- A "How it's drawn" panel explaining the pipeline. Stacked mobile layout with no horizontal scroll.
One prompt - two passion fruits. And Opus takes the jelly crown again 👑
For $10.91, it delivered juicy colors, textured skin, and pulp you just want to poke. Everything stretches, jiggles, and looks delicious
Astra needed two rounds of fixes: the insides were separating and showing through the skin, and changing the color literally spawned a new fruit. After the fixes, the estimated API cost hit $27.45
2.5x the price, yet Opus still looks juicier
So what exactly are we paying extra for? 👀
PROMPT:
Build a real-time WebGPU soft-body "jelly" study of a halved passion fruit, same engine and editorial page style as my Melon / Avocado / Peach jelly slices. Geometry from SDFs: a slightly squashed sphere cut flat at the top, a thin wrinkled purple skin, a ~0.15 R white pith wall, and a hollow filled with lumpy translucent orange pulp sitting a little below the rim. Sim: CPU XPBD co-rotational shape matching + volume constraints on a 5-tet hex lattice, 10 substeps at 60 Hz, with per-tet regions — a firm, leathery rind cup and a very soft pulp whose volume constraints are compliant, so grabbing the pulp makes it neck and stretch like goo and slump back instead of lifting the whole fruit. Render a surface-nets mesh skinned to the lattice: refraction, Beer–Lambert absorption, subsurface scattering, Fresnel studio reflections, GGX, shadow map, contact AO, PBR Neutral tone mapping. Shader regions from rest-space SDFs: rounded wrinkle bump on the skin (faded at grazing angles and distance), pale pith, a thin yellow membrane lining the hollow, soft Voronoi juice-sac cells in the pulp; ~100 dark flat teardrop seeds and a few bubbles embedded in the pulp so they ride the wobble. Varieties: Purple, Golden, Granadilla. Controls: firmness, internal damping, nudge, reset, ¼ speed, show mesh, pause; mass/volume/kinetic readouts; "Inside the experiment" notes. English UI, mobile-friendly.
A basketball court built by Claude Opus 5.5 for $10.1 🏀
A tiny pixel-art diorama with a game in motion: players run across the court, take shots, and put points on the scoreboard
You can zoom in, change the time of day, and turn on the rain. As evening falls, the lights come on and reflections appear on the court - giving this little neighborhood scene a whole new atmosphere
The video captures 18 seconds of its little world
What do you think of the result for $10.1? 👀
PROMPT:
Build "Corner Court" — a single-file, real-time three.js (r160, ES module via import map from jsDelivr) page: an isometric diorama of an original street basketball half court on a floating city block, rendered as crisp pixel art. UI text in English.
RENDER PIPELINE
- Orthographic camera at ~31° elevation, azimuth 45° + 90° steps (animated; drag sideways or buttons), wheel/pinch zoom; fit the whole slab into the free screen area.
- Render into a small target (screen / pixel size) with no anti-aliasing; snap the camera to whole pixels.
- Post pass:
- depth outlines (darken a pixel >0.55 m in front of a neighbour);
- nearest colour of a fixed ~54-colour city palette in OKLab (concrete/asphalt greys, sky and night blues, court teal, terracotta/orange, reds, yellows, leaf greens, skin/wood, dusk purples, neon pink); optional 4×4 Bayer dither;
- whole-pixel upscale via texelFetch; the background (depth = 1) is the page colour.
- Hard shadows (BasicShadowMap); flat-shaded Lambert low-poly.
- Puddle reflections: render the scene mirrored about the ground (scene.scale.y = -1, ground meshes and rain hidden) into a second target, sampled at gl_FragCoord in the ground shader.
- "Raw 3D" mode: the same scene at full resolution with MSAA.
SCENE
- A ragged-edged slab: grass over soil over rock.
- An asphalt pad painted texel-by-texel at 10 px/m: teal inside the 6 m arc (straight corner lines), terracotta key, white lines, free-throw and restricted circles, cracks, worn paint, a stencilled "COURT 7".
- Hoop: padded navy pole, arm, backboard with its square, orange torus rim, and a line-segment net that sways when the ball goes through.
- Chain-link fence behind the hoop (alpha-tested diamond texture).
- A brick corner shop with an awning, lit windows, a pink "OPEN" neon sign and a vending machine.
- A long wall with an original sunset-city mural.
- A sidewalk with a bench and two seated spectators.
- Floodlights, a streetlight, low-poly trees, hedges, a dumpster, a fountain, a bike rack with two bikes, a hydrant.
- Pigeons that peck and fly off when players or the ball come near.
PLAYERS — procedural rigs of ~17 boxes
- Two-bone IK for legs (running stride, defensive slide, tucked jumps) and arms: dribble hand following the ball, jump-shot set point with release and gooseneck follow-through, layup reach, two-hand dunk, chest pass, rebound/contest reach, celebration.
- Spectators sit, cheer on makes and open umbrellas in the rain.
GAME — streetball 2v2 half court
- Make it take it; 1s inside the arc, 2s beyond; first to 11; win counter.
- Check ball at the top (pass to the defender and back). A change of possession must be cleared beyond the arc.
- Offence AI: dribble to spots, drive when the lane is open, pull-up jumpers when open, layups/dunks at the rim, passes when pressured; the off-ball player spots up or cuts. Man-to-man defence with stance, gap control, steals and contested jumps (blocks).
- Ball physics with substeps: bounces on asphalt, sphere vs torus rim and backboard box, net drag, pole, fences, wall, slab edge.
- Jumpers aimed on a ballistic arc (~50°) with speed/aim noise growing with distance and contest.
- Layups lofted to a peak above the rim so they drop in.
- Rebounds with jumps; out of bounds goes to the other team.
- Score, possession and status messages ("SWISH", "BLOCKED!", "TAKE IT BACK", …) on a lit scoreboard.
- Clicks: the ball handler shoots, his teammate gets a pass, the court sends the handler there. Shoot/Pass buttons.
WEATHER AND TIME
- Day / Dusk / Night lighting presets blended over ~1.6 s; floodlights, streetlight, neon and windows at night.
- Dry / Drizzle / Downpour: rain as short line streaks with splashes. A wetness value rises and slowly dries: the asphalt darkens, puddles spread from low spots in a precomputed depth map and mirror the scene, rain rings flicker in them; feet and the ball splash.
UI
- Pixel display font (Silkscreen) and a clean body font; light/dark themes via tokens.
- Controls: Time, Weather (with a court wetness bar), Shoot, Pass, New game, Pause, Turn left/right, Pixel art/Raw 3D, Pixel size, Palette/Dither/Outlines.
- A "How it's drawn" panel; a stacked mobile layout with no horizontal scroll.
Opus at $13.4 vs Astra at $23.51 - who made the better plush lobster? 🦞
Top - Claude Opus 5.5. Bottom - ChatGPT-6 Astra.
Opus nailed the physics and fur: the body has a soft, satisfying bounce, and the fur looks genuinely fluffy - you actually want to touch it
Astra has a funny face, mismatched eyes, and a personality of its own. Looks like it’s already been through a lot
But for physics and that plush-toy feel, my vote goes to Opus. At almost half the price, too
Which one’s your favorite - top or bottom? 👇
Check prompt:
Build a real-time WebGPU plush-toy study of a cute stuffed lobster, in the same engine and editorial "Material Studies" page style as my Plush Crab (shell-rendered minky fur, XPBD soft body, wired legs).
Body: one signed distance field — a long domed carapace with a rounder face and a small horn, two short eye stalks with big glossy safety eyes on white felt discs, an embroidered smile and rosy cheeks, then a tail of six smooth-unioned segments that get smaller toward the back, with a crease between each, ending in a flat five-paddle tail fan. Fill it with a hex lattice of cells and tetrahedra, solved with co-rotational cell shape matching plus volume constraints on a fixed 60 Hz step; Coulomb friction on the table. The shell breathes. Only the shell keeps its footing and posture, so the tail stays free.
Tail muscle: along the tail's centre line, lengthen the cells' rest shapes above the line and shorten them below, so the stuffing itself curls the tail. At rest the tail gently lifts and settles. "Tail flip": snap the tail under hard in about 0.1 s with extra cell stiffness, throw the body back and up, and straighten the tail again mid-air so it lands stretched out well behind where it started. A finger poke on the shell triggers the same flip.
Chains (XPBD rods with a plastic wire, posed in the body frame, blended poses lie/stand/tuck/wave/hang):
- eight thin walking legs with pale knitted joint bands;
- two arms ending in a big padded palm with two plush claw fingers (dark felt tips) that open and close by one angle;
- two long thin striped feelers that sweep up and back and always twitch slightly.
Behaviours:
- walking: head first, an alternating gait with footholds on the table;
- "Snip snip": both claws open and shut out of step;
- "Wave claws": claws raised and waving;
- Finger tool: the lobster walks to the finger, faces it and pinches it gently;
- held up, its legs dangle;
- pulling a limb past its reach tows the whole body.
Rendering: fur shells with Kajiya–Kay highlights, a velvet lie the Comb tool can brush, and pile that sways on springs. Draw the tail seams as stitched short-pile creases and give the fan pale edges. Soft shadows, contact AO, a studio backdrop, PBR Neutral tone mapping.
Varieties: Red, Blue, Golden. Tools: Hand, Finger, Comb. Sliders: stuffing, pile length, wire. Buttons: Walk, Snip snip, Tail flip, Wave claws, Straighten, Smooth fur, Reset, ¼ speed, Mesh, Pause. Readouts: mass, volume, steps, flips, snips. Add an "Inside the experiment" notes drawer. English UI, mobile-friendly.
Opus 5.5 claude.ai/artifact/DAtixcg94…
GPT-6 Astra plush-meme-lobster.vercel.ap…
The jelly king found a knife 🍉🔪
Claude Opus 5.5 turned my jelly watermelon into the most distracting thing in my browser. Slice it up, pull the pieces apart, throw them around. Every chunk keeps bouncing like nothing happened
The watermelon cost $4.46. Adding the knife and cutting physics took another $8. Total: $12.46
The knife cost more than the watermelon, but cutting it up is the best part
prompt:
Build a real-time WebGPU soft-body "jelly" study of a watermelon wedge that you can cut with a steel knife, in an editorial "Material Studies" page style (serif title "Melon Jelly.", muted paper backdrop, side panel, English UI, mobile-friendly). Geometry: a thick triangular watermelon wedge with a rounded green rind, a pale white layer, and translucent red flesh with dark seeds and a few air bubbles. Sim: CPU XPBD on a tetrahedral mesh, fixed 60 Hz step with 10 substeps. Each tet uses a co-rotational shape-matching constraint with finite compliance, which also flips inverted elements back out, plus a near-incompressible volume constraint so a stretched slice necks in. The rind is about 3× stiffer than the flesh. Damping acts only on relative velocity along edges. Floor contact uses Coulomb friction. Grabbing is a soft, reach-limited attachment to a patch of particles, and scroll or a second finger twists it.
Two tools, Hand and Knife:
- Knife: the user draws a stroke across the slice. Read on the surface, that stroke defines a vertical blade plane. Every piece is stored as a rounded convex outline in the slice's rest plane. For each piece the plane crosses, fit the piece's current pose with a best rotation, carry the plane back to rest space as a straight line, and split the outline along it.
- The cut: prebuild both halves as fresh tet meshes on release. An animated steel knife lines up over the stroke, comes down, and first presses a groove into the jelly. When it breaks through, swap in the new pieces, which inherit the position and velocity of the flesh they came from, and the blade wedges the faces apart on its way to the board. Draw the blade behind the jelly surface so the buried part is seen refracted.
- Pieces: every piece is its own soft body that can be grabbed, stretched and cut again, and pieces collide with each other instead of passing through.
Render: a smooth surface mesh plus the seeds and bubbles, each vertex embedded in a tet by barycentric weights so they ride the wobble. WGSL passes:
- floor, seeds and bubbles first;
- back faces, to get the thickness each view ray crosses;
- front faces with refraction by that thickness, Beer–Lambert absorption, milky scattering in the pale layer, a back-lit glow at thin edges, Fresnel reflections of a procedural studio, and GGX highlights;
- a soft key shadow on the floor tinted by the jelly, plus contact AO from a top-down height map.
Varieties: Crimson, Golden, Rosé. Controls: Hand/Knife tool toggle, firmness and internal damping sliders, "Give it a nudge", Reset, Pause, ¼ speed, Show mesh, plus mass/volume/kinetic readouts and an "Inside the experiment" notes drawer explaining the physics, cutting and rendering.
