Making of "Hello World"
The reference demo taken apart

The instance's fourth colour channel is a code as well as an amount, and object.frag reads it that way:

• From 0 up it's emission, at 4 × base². The logo's cubes, the end card's syllables and the seed use this.
• Below 0, down to -1.6, it's the crowd's softer glow. build_bodies gives a third of the crowd an emission between -0.8 and -0.3, which animate scales with the beat and the energy. A combine's flash takes it further, down to -1.6, and makes a plain body glow the same way for a moment. object.frag turns it into 3 × base² × -emission × (0.3 + 0.7 cos θ).
• Anything under -3 is a bubble of air under water. Scene 2's bubbles use -4, well clear of the crowd's codes (see What draws it).

The base colour is squared so that a glowing pastel keeps its hue through the tonemap. Squared, the palette's pink (1, 0.42, 0.62) glows as (1, 0.18, 0.38). So it stays pink instead of burning to a white tile with a tint, and the bloom carries the colour. The crowd's glow is full in the middle of a face and a third of that toward the silhouette. That way the key light, the clear coat and the rim still model the glowing bodies: they glow and bloom on the beat and are shaded plastic in between.

The crowd has three materials. A quarter of the bodies are tinted glass, a quarter are iridescent and the rest are pastel plastic. build_bodies makes every other odd-numbered body glass and the rest of the odd ones iridescent. The even ones, and whatever a combine makes, are plastic, and so are the logo's and the end card's cubes. The material is carried in the signs of the colour, set once at load: a negative red means glass and a negative green means iridescent. That way animate, the sim and object.vert don't need to know, and object.frag takes the colour's absolute value. Everything else it draws (Scene 2's eyes and marine snow) is plastic, except Scene 2's bubbles, which are air (above).

• The iridescence is a thin film over the plastic, about 0.4 µm thick with index 1.33, like a soap film or a beetle's shell. Light reflected off its two faces meets again out of step by 4π n d cos θ_t / λ. So its reflectance, 0.5 - 0.5 cos of that, comes and goes with the wavelength (650, 550 and 450 nm for the three channels) and with the angle. Face on it's magenta, going through gold and green to cyan at the edge. It's lifted to 0.3-1 and mixed 60% over the body's pastel, so it stays in the palette.
• The glass is drawn last, after the blob, through a copy of the picture so far, the way Scene 2's jelly is. The copy is Scene 2's jelly_copy, the whole frame in RGBA16F on unit 9. The glass reads it along the ray bent into the surface (index 1.33), tinted by its pastel more the deeper it looks in (Beer-Lambert, exp(-2 (1 - base) cos θ)). It keeps 15% of the plastic's light, as if frosted, and mirrors the sky toward its rim by (1 - cos θ)³, which is Fresnel's shape. The clear coat's glint and the beat's emission go on top.
• It reads the copy 0.7 m × cos θ / (1 + k) along the ray, where k is the surface's curvature: one over its radius, from the derivatives of the normal and the position. The cos θ makes the edge, which turns the ray fastest, bend it least. Dividing by 1 + k keeps the picture behind from being magnified past a fold, such as a cone's tip or a box's bevel, which would focus the copy's pixels into stair-steps. The distance stays at 0.7 m because k comes from derivatives, so it's one value per 2x2 pixel block. The point read jumps from block to block, and the jump grows with the distance. At 0.7 m the steps stay at a pixel or two, and the torus and the ball still clearly bend the grid behind them.
• s1_shapes sorts each shape type's glass to the end of its instance list and draws instance ranges (mc_mesh_draw_instance_range): the solids in the lit pass, and the glass after the blob and the copy. When there's no glass, as on the end card, no copy is made. On the UHD 620 at 2160 lines the copy, which is bound by bandwidth, costs about 5 ms a frame, and the glass's shading about 2 ms.

The key light casts shadows, so the bodies shade each other, and the end card's letters do too. Each frame s1_draw first draws the shapes again, from the light, into Scene 2's sun map, uw_shadow. Scene 1 and the end card never share a frame with Scene 2, so the map is free while they run (see The renderer evolves). The map is 2048 x 2048 texels over an orthographic 32 m box round the origin, which makes 1.56 cm texels. That's big enough for the logo's cubes as they fly in from up to 16 m out. object.frag reads it through keyShadow(), which takes nine bilinear depth-compared taps 2 texels apart. Each tap's 2-texel filter meets the next, so the penumbra, about 9 cm wide, ramps smoothly. 4x4 taps look the same and cost 1.8 ms more on the UHD 620. The taps start from the point nudged 4 cm off the surface along its normal, so a face doesn't shadow itself.

In shadow the key light doesn't fall to nothing but to 0.4 × the albedo squared. So the shade stays the shape's own colour, only deeper, as if the light had soaked into the plastic. A plain shadow would turn the dawn act's pinks slate grey.

The glass casts a third of a shadow, which gives a lighter pool on the floor and a lighter shade on the bodies behind it. The key light's depth pass draws it separately (pass 3 of s1_shapes) through object.frag. That shader sees that the camera is the light (uViewProj = uLightVP) and returns at once, after discarding two of every three diagonals of the map's texels. keyShadow's 3x3 taps lie 2 texels apart, so their diagonal offsets, 2 (i + j), land on each of the three diagonals three times. Wherever they fall, they average the pattern to exactly a third. A pattern with a period of 4 would leave a ripple of up to 0.06 that crawls as the light goes round. That's stripes 2 on and 2 off, or a 2x2 checker, which also gives half a shadow. The solids keep the plain depth program (shadowsh, pass 0).

Scene 1 uses uAtmo for three things. It's Scene 2's sky ramp, a field of the Frame block that Scene 1 has no other use for.

First, before the bang the universe is dark. The whole sky, glow included, sits at a quarter of its level, so a lone seed with a tight halo hangs in a near-black void with faint stars. The bang is then a hit from dark to light.

Second, on the bang uAtmo runs from 0 to 1 over the 0.4 s after the kick, and sky.frag draws the shock front. That's a ring racing out from the seed's direction, with a sharp outer edge and a short trail inside. At the front is a bright band whose rim glows rose white, (4, 2.8, 3) × its strength, the dawn act's colour. It's the bang's flash, sweeping across the frame. A longer trail would light the whole inside evenly, as a hard flat disc. As it passes, the ring bends the sky like a lens, pulling each ray in toward the seed. So the origin's glow is dragged out into the rim and the stars swim through it. It weakens as it grows and leaves the frame in about 0.2 s. Behind it the light ramps back to full over 0.25 rad. Ahead of it the dark only creeps up (0.6 × uAtmo), so outside the ring the light only ever grows, and floor(uAtmo) holds it at full from then on. The origin's glow flares for 0.8 s after the kick. Its wide halo lasts about 0.15 s, and the crowd's colours show within half a second of the kick.

Third, over the outro uAtmo runs from 1 to 2 in the 3 s before T_BLACK (46.2-49.2 s). The sky, its glow and its stars go down to black with it, while the seed, which object.frag draws, goes on shining alone. The world goes dark round the star the camera has backed away to (The Catmull-Rom camera). At 1 nothing changes, and the end card sets that value itself (The end card).

Behind the title and the end card a synthwave sun stands on the horizon, directly behind the origin from wherever the camera is. It's a disc 0.4 rad (23°) across, gold at the top and hot pink at the bottom. Its lower part is cut by bars that thicken toward the horizon, which hides the part that has set. The bars are a quarter of a radius apart, each with a gap of 0.5 × (0.6 - y) of that, with y going up the disc from -1 to 1. A pink haze lies along the horizon and round the disc. The sun is blended over the sky at about the sky's own level, not added, because added it would wash out to a pale peach in the shoulder of the filmic tonemap. The floor (ground.frag) reflects it the way a wet road would, as a narrow streak running down from the horizon under it.

The sun's height over the horizon and its presence travel in uSun, which no Scene 1 shader has another use for. render_scene1 ties both to the title's presence (lv, which also dims the glow). As the cubes gather, the sun's centre rises 0.32, from 0.24 below the horizon to 0.08 above it, and it sets again as they scatter. No act before the finale sees it or its haze. The end card sets it over its five bars, from 0.1 to -0.14, under its fade. The finale's sky above the horizon (SEQ_TOP) is a deep violet, (0.40, 0.20, 0.85), so the pastel letters and the blob stand out against it.

space.frag (full-screen, sharing sky.vert) draws deep space and cross-fades it to a blue sky as its uAtmo climbs, so one shader carries us from orbit down through the atmosphere. Space is near black, with a field of steady stars: one cell in 40 of a grid 200 cells to the screen's height holds a star. A star can sit anywhere in its cell. Its brightness is a steep power of a hash, so most are faint and about 2% are bright, and its colour runs from red-orange to blue-white. The stars don't twinkle, since there's no air to twinkle through. One cell in 30 of a grid eight times coarser holds a brighter star, with a glow and the lens's four spikes. The sun is a sharp disc 14 px across at 1080p, darker toward its limb. It sits in a tight glare that falls off with the square of the angle, plus a faint veiling glow. Those distances are measured in screen heights, so the glare is round.

A faint band of the galaxy crosses the sky diagonally behind the planet, clear of the sun. Its unresolved starlight is an fbm stretched along the band, warm white at the heart and bluer at the edges. A finer fbm, stretched 4:1 along the band, splits it down the middle with dark lanes of dust, and more stars crowd it, one cell in 15 at its heart. Knots of faint pink glow along it, where its gas is lit. At its brightest it's only 0.05, so it shows as structure without fogging the sky, and it fades with the rest of space as the sky turns blue. The band is separate code and could be dropped on its own.

On the plunge the sky is laid out on the screen, pale at the horizon and deeper blue overhead. From the cloud break on (floor(uAtmo) = 1, under the white-out), it's laid out by the direction each pixel looks, through inverse(uViewProj). That's mix(uSky, deep blue, sqrt(3 × elevation)), a pale band at the horizon and blue from about 20° up. Its glow sits round the true sun (uSun), up to the left above the glitter path, and the sea mirrors the same sky (see The sea from above). So the glow stays put as the camera pitches, and sky and sea meet at the horizon in one colour.

planet.vert makes the planet from gl_VertexID: 48x48 cells on each face of a cube, pushed out onto a sphere. In planet.frag, continents, oceans, ice caps and drifting cloud are all 3D fbm noise over the object-space direction. That's six octaves of value noise, each turned as well as scaled so that the lattice never lines up. Each octave is one fetch from the demo's 32³ lattice of random bytes. That lattice is vn3, the value noise every shader shares (see Engineering notes). One broad field warps the rest. That gives coasts that wander and break into islands, a deep ocean with a paler shelf along the coasts, forest or desert where the broad field says wet or dry, and bare uplands. The ice caps have a ragged edge and reach further down over land than over the deep sea.

The cloud streams in bands. Its field is squeezed north-south, pushed by the land's two fields, swirled into fronts and eddies by two fbms of its own, frayed by one six times finer and cut by a narrow step. It drifts, shades the ground under it (it's read again a step toward the sun) and is darker on its own side away from the sun. The cloud's three fbm fields cost about 2 ms at 1080p as the planet fills the frame.

The sun lights the planet from the backdrop sun's side, about 68° off the eye (uSun × (1.7, 1.5, 0.1)), so in space a third of the disc is night behind a soft terminator. On the plunge the sun swings round behind the eye with uAtmo, so no night side hangs in the blue sky and we fall into a sunny noon.

The air is Rayleigh scattering plus ozone, in closed form. air(s) is sunlight reddened over an air mass of 0.1 / (s + 0.1)². Rayleigh takes blue first, and the ozone's Chappuis band takes a fifth to a quarter more of the green and red. The extinction is (0.0073, 0.0176, 0.033) where Rayleigh's alone is (0.006, 0.014, 0.033), the column ratios of Bruneton's 2017 model. The light is white overhead, faintly warm at 30°, orange low down, red at the terminator and dark past it, and it lights the ground. Without the ozone, the low sun would turn yellow and then green against the air's bluish scatter, one more band of rainbow on the way down.

The air between the ground and the eye dims the ground by its transmittance along the view, e^(-τ / n·v), where τ is the Rayleigh depth straight up. It also adds the light it scatters on the way. That light is lit by air() at the ground's sun, but it takes only half the tint: (A + A.r) / 2. The other half is the red's strength as a grey, which is how the sky's own light would look once scattered again. The result is a blue haze that thickens to a pale limb, faintly warm at the terminator and gone at night. Red is the last channel to go, so the glow fades out where the sunlight does. The full tint would go wrong near the limb, where the scattering saturates every channel. There the air would send out the sun's own colour at each height of the sun, and air() runs through the whole sunset within about 0.2 of the sun's cosine. So each end of the terminator would wear a saturated rainbow sliver a few pixels wide. With the half tint the rim fades from the blue-white limb through a faint peach and lavender tip into the night.

Only the sea has a sheen, broad and faint and weighted by Schlick's Fresnel. It's a Blinn lobe of exponent 60, scaled by 5, to match the 0.17 rms slopes of wind-roughened water (Cox and Munk's figure at 5 m/s). A tighter, brighter lobe looks like plastic. Where there's no cloud, the land's height above the sea bends the normal the ground is lit by, through its screen-space slope. That's the surface gradient, taken from the fine derivatives, because the coarse ones show 2x2 blocks. Mountain ranges catch the sun on one side and fall into shade on the other, most of all near the terminator, while the air keeps the smooth normal. The footprint's area under that slope is floored at 10⁻⁹. Edge-on at the limb it reaches 0 over a sea whose slope is 0 too, and the TAA's history has no NaN guard, so it would keep the 0/0.

atmo.frag (sharing planet.vert) draws the same sphere 6% larger and adds it on with the front faces culled, so it only shades the ring round the disc. Each pixel's ray scatters 1 - e^(-t) of the sunlight, where t is the Rayleigh depth along the ray. That depth falls off exponentially with how high the ray passes over the ground, so the halo hugs the limb. It's 66 τ e^(-50 h), with h in shell radii, matched to the disc's limb. Near the limb the depth saturates every colour and gives a pale band. Higher up it saturates only blue, which leaves a blue fringe fading to black. The light it scatters is air() where the ray passes, with half the tint as on the disc. It's white on the day side, a faint peach at the terminator's two ends and nothing on the night side. Its sun turns with the disc's, so the two meet at the limb.

In the planet frame the post's lateral chromatic aberration scales as (1 - uAtmo)², so it's gone where the sky is blue and unchanged in space, over the sea and under it. At full strength it would pull red from the bright sky into the edge pixels of the planet's dark limb, as a red line a pixel wide.

The moon (moon.frag, drawn on planet.vert's ball) is a fifth of the planet's size. It sits 65 units out toward where the camera comes from, and 23 units off the camera's line of approach. As the camera drifts in, the moon hangs low to the right of the planet and slides outward against it, which is the shot's only parallax, since the stars are at infinity. When the plunge passes it, the moon swells and sweeps out past the right edge, never coming nearer the lens than 23 units. Its surface is dust over old lava plains: broad darker seas and mottled highlands, with a gentle relief taken from the mottling's own field. From this far the moon shows mostly through its albedo. A relief strong enough to read as rock makes it look like an asteroid, and the post's colour fringes run purple round it. It's lit by the planet's sun, turned the way planet.frag turns it, so the two show the same phase. With no air, the terminator is hard.

ocean.vert / ocean.frag draw the sea surface. ocean.vert makes a 900 m plane of 140x140 cells from gl_VertexID and raises it into a swell with a sum of four directional sines, and ocean.frag sums the same sines again per pixel, with their slopes. On top it adds five finer octaves of chop, each turned 2.4 rad from the last at 1.9 times its frequency and moving at deep-water speed, and a value-noise cat's-paw on the slope. The finest two octaves make the ripples close up. So near the eye the surface is smooth and lively, instead of showing the grid's 6 m facets.

Each of these layers fades out by fwidth where it would alias. The cat's-paw's 0.6 m cells fade between 0.25 and 0.8 cells a pixel. Any later, and through the fall's mid-distance they'd be 1-2 px across and sparkle like grains of salt. The variance of a faded octave's slopes, which is how far it would have tilted the surface, goes into the roughness instead (LEAN / Toksvig-style normal filtering). The sun's glint is GGX: D F / (4 n·v) n·l, with α² = 0.64 r over a base of 0.003 and Schlick's Fresnel at the half vector. With the filtering it gives a sharp sparkle up close, a smooth glitter path far off and clear ripple highlights in the skim.

The sea reflects the sky by Schlick's Fresnel (F0 0.02). It's the same sky space.frag draws behind it, glow and all, so the sea brightens round the glitter path. From 200 to 440 m the far sea melts into the haze at the horizon. Sky and sea meet in one colour before the edge of the 900 m plane can cut the sky in a line. The water's body runs from deep blue troughs to turquoise crests that the light shines through, more so looking toward the sun.

Foam breaks only on the higher crests (1.4-1.7) and thins out inside them, its opacity ramping over 0.45-0.75 of its noise. A finer octave frays it into lace, and it's torn into streaks along the wind, in broken patches a metre or two across. Its cells are about 2.9 by 0.8 m and drift downwind. Much larger cells give one soft blob per crest, like paint. The noise evens out where it would shrink under a pixel. Inside, foam is bubbles. A fourth octave of its noise, round and about 15 cm across, drifts with the foam and crowds and thins it. It uses two lattices turned against each other, because one alone shows square cells that look like pixels. The foam is brighter where the bubbles are packed, the water shows through where they're thin, and they fray its lace edges too. This octave also evens out where it would shrink under a pixel. The slope the foam lies on, the chop's normal, turns it toward the sun or away. The foam's bubbles cost about 1.4 ms a frame over the fall.

water.frag is the underwater backdrop: the water along each pixel's view ray (see The water's light). It's full-screen, and far.vert puts it on the far plane and hands it that ray. The light it scatters brightens toward the surface and toward the sun. Shafts cross it, the caustic web's light carried down as sheets. The ray samples them six times, crowded into the near metres. They're sharp near the surface and blur with depth: the contrast is 1 at the surface and 0.75 at 10 m, and never drops under 0.4. They sway with the swell and fan down from above the frame. The shafts hang from the eye's path, smoothed over the half second around now, and give way to a broader, softer pattern when the eye flies or swings fast.

Looking up, the ray meets the surface from below. Inside Snell's window the whole sky and the sun are squeezed into a disc 97° across. Its rim splits into a thin rainbow, because each colour has its own critical angle (n 1.331 / 1.334 / 1.340). Outside the window, total internal reflection mirrors the dark water. Eight ripples on a geometric spectrum break both into moving facets, whose curvature focuses and spreads the light through each one. Each ripple fades out before it gets too fine for a pixel to hold. When the eye moves fast the rim softens, and the facets and the sun's hot spot calm down along with the shafts.

Specks of particulate drift in the water, fixed to their view directions. One cell in 25 holds a speck, each with its own size up to half a cell, and the larger ones are dimmer. So the small ones are sharp points and the large ones soft, dim discs, as if they were nearer and out of focus. Specks of one size and brightness would look like a stencil laid over the open water.

uwsurf.frag (with object.vert for the seabed and rock.vert for the boulders) shades the underwater surfaces. A per-instance material id picks the look: baked sand or rock textures, sampled triplanar, or a live procedural rock colour. So the scene mixes textured and procedural surfaces. The sampling is really biplanar: of the three planes it skips the one the surface faces least, fetch and all. It runs the shared physically based model of GGX, analytic IBL, detail normals and the water's extinction, with the caustic web folded into the sun's radiance (see The renderer evolves (the uQ ramp)). The seabed's base sand breaks up its tiling with tnt(), as the beach does in Scene 3. A second ramp, uReal, layers finer detail textures over the base, a 4x octave and then, as the ramp nears its end (uReal=²), an 11x micro-grain, while =uQ blends the whole thing up from a flat early look. Both ramps are complete by story second 48 (110.4 s), so the floor and the rocks gain a lot of definition over the act's first half.

The rock is a warm grey stone (0.20-0.50 baked, 0.16-0.42 procedural, brown-grey). Silt has settled on its upper faces as a pale, sandy film, deepest in the hollows of its relief, so the rocks belong to the floor they sit on. The silt is a constant colour, since at these sizes a silt textured like the sand looks no different. Underneath, the rocks are lifted by the sand's light bounced back up, which the analytic environment carries (see The renderer evolves). uwsurf.frag also lights the seabed and the boulders with the jelly's caustic (see The jelly).

Where the coral patches, the landmark reefs and the flight's last coral stand, the floor itself turns to reef bed, so the heads sit in one reef instead of on pale sand. For each 3.5 m square of the sand, the placement leaves two things: how much bed the coral heads around it lay down, and the time from which it may grow in (see The seabed and its props). The sand blends the bed of the four nearest squares bilinearly, up to 1, and grows it in over 4 story seconds. Two noise octaves fray its edge into the sand, because with one, a straight 3.5 m edge shows. The bed is rubble and crusts of growth, mottled ochre, olive and dusty rose and darker in its crevices, with a low relief of its own through the detail normal. Through the flight it costs 2.7 to 4.3 ms a frame at 150% on the UHD 620, for the sand's four fetches and five noises a pixel.

rock.vert (which feeds uwsurf.frag) gives the boulders progressive geometry. Three octaves of crags are baked into the rock at load by uwplace.comp, and the mesh's indices pick its vertices from that buffer. On top of those, a per-instance 3D-noise displacement grows along the surface normal as uReal rises, and its higher octaves fade in later. The rocks gain crags and fine relief as the scene goes on. A three-tap finite difference rederives the normal from the noise gradient, so the new geometry is lit correctly. Each boulder is also squashed and stretched per axis (0.7-1.1, seeded by its position) and dented by one broad noise octave that only ever pushes inward, so no two share a silhouette. Because the placement leaves headroom for this growth, the rocks still never touch anything. The shadow pass uses the same vertex shader, which keeps the shadows matched.

Each boulder darkens toward its foot, where it's bedded in the sand. Its centre stands 0.35 of its scale above the sand (uwplace.comp's seat), and a vertex's tint runs from 0.3 at 0.45 of the scale below the centre to 1 at 0.25 above. That's the shade, silt and wet where the rock meets the sand, which the GTAO, with a metre's reach at half resolution, barely draws under a convex rock. The tint rides in vColor, the albedo tint uwsurf.frag already applies, so the shadow pass is unaffected.

The sand darkens round each boulder's foot as well. For the sand only (uSandOnly), uwsurf.frag walks its square's list. For each boulder that's born, grown in and not yet overgrown by a landmark, it darkens all of the sand's light by up to half. How much depends on how near the point lies in the boulder's own frame. To work in that frame it undoes the boulder's turn (Rodrigues) and divides out its size and rock.vert's squash, so the shade is an ellipsoid that hugs the rock's outline. It's full at 0.6 of the rock's size, which is always inside the rock, and fades smoothly to nothing by 1.8, as 1 - smoothstep(0.6, 1.8, h). On the side away from the sun, where the cast shadow already darkens the sand, it's up to 15% tighter. Without it the rocks would look set down on the sand instead of bedded in it. The foot's tint stops at the rock's own edge, and the cast shadow lies on one side only and fades out past 35-40 m. With it each rock sits in a soft skirt, near and far, that follows the caustic web and doesn't cut across it. The shade dims all of the sand's light, because dimming the ambient alone blackens the web's dark cells beside a rock while its bright lines stay. Rock on rock, coral and weed get no contact shade. The sand's shade costs 0.6 to 2.8 ms a frame at 150% on the UHD 620.

uwbake.frag is the material baker. Once at load it renders four tiling textures into repeat-wrapped, mipmapped 2D textures: sand and rock for the seabed, plus a fish-scale skin and a whale skin. The two skins are sampled through real mesh UVs (below). The sand and rock are filtered 4x anisotropically, like Scene 3's tiles, so the floor and the rocks stay sharp where they slope away. The skins aren't, because on the scales it only sharpens the moiré (see Fish and the big school).

The fish, the crabs, the predator and the whale are all sculpted at load by the creature kit that also makes Scene 3's tyrannosaurus (jr.comp, described in The tyrannosaurus). Each is a smooth union of round cones, ellipsoids and flat fins in its rest pose. The fish's body is an ellipsoid whose section tapers toward nose and tail, and its fins are thin triangles. The whale's body is a loft, section by section. The predator's body is cut off at the hinges of its jaws, and each jaw is sculpted shut and then turned open to the rest gape fish.vert assumes (see The predator). Each animal is meshed by surface nets on a grid of its own. The cells are 0.06 for a fish, 0.07 for a crab, 0.015 for the predator and 0.014 for the whale, in model units, which the instances scale.

They all go into one shared vertex buffer. Each vertex carries the two bones that hold it, from among the body, the upper and lower jaws, their fangs and the fins. On the predator it also carries a mark for whatever lies inside the mouth. That's about 3,100 triangles a fish, 3,200 a crab, 22,000 for the whale and 60,000 for the predator. fish.vert poses all four, reading that buffer by gl_VertexID in the usual instance batches, and a per-draw flag tells it which animal it's posing. The fish and crabs swim with a wag that travels down the body, the predator works its jaws as well, and the whale beats up and down.

fish.vert / fish.frag draw the fish. The body tapers to points at the nose (+Z) and the tail (-Z), and a forked tail, a dorsal and two pectorals give it a proper silhouette. The vertex shader wags the tail with a sine wave down the body. The fish swim in circling schools, seated at even angular spacing on the ring so that school-mates never collide. They point nose-forward along their direction of travel (the yaw is atan2 of a one-step look-ahead), so the fin trails at the back and they move the way they face. They're shaded procedurally, with a dark back, a light belly and faint banding, plus a specular glint and an iridescent Fresnel that both tighten and strengthen as uReal rises.

The body samples the baked scale texture at coordinates taken from its rest-pose position, cylindrically round the +Z axis, so the scales stay on the body as it swims. The texture drives the albedo, the scales' relief (as a detail-normal height) and the roughness, all blended in by uReal, so early fish look procedural and late fish are fully textured. As a scale shrinks from 6 to 3 pixels across, the scales are eased to their mean, the texture's last mip (scales(), by the UVs' fwidth). Any finer and their rows beat against the pixels. The beating is faint in the albedo and strong in the detail-normal relief, whose slopes grow with the frequency, and mip-mapping alone doesn't stop it.

scales() takes the footprint's scale as well. The predator's scales are three times finer than a school fish's, and they're eased to their mean from 18 to 9 pixels across. At those sizes their fine, even net looks like chain mail and crawls as the predator sweeps past the lens. So its flank is dark slate, and its scales only show where they're big, on the head as it passes the lens. The flank gets a quiet texture (0.8-1.2 of the albedo, with a faint relief of 0.02 + 0.04 uQ) and the fins get none, so they show only the rays of their spines. Where the scales are faded, the rim light their relief would catch on average is added back, 0.1 of the rim colour, so the skin keeps its brightness as they come and go.

The fins have their own bone and are shaded apart from the body. Each is a thin membrane in the fish's tint over rays fanning out from its root, turned to the viewer and lit through from behind. It's brightest looking toward the sun (a forward lobe after Barré-Brisebois) and has none of the body's scales or sheen.

Besides the circling schools there's a big school of 300 small fish, holding station round the blob's path where the blob passes at story second 92.5 (BIG_U, 146.0 s of the show). The blob bolts straight through it. The fish dart aside and a channel opens, the camera flies down it, and it closes behind. fish.vert places the school itself (uK's 32) as an analytic flow round the known path, with no flock to simulate. Instance i is a slot on Vogel's spiral (the golden angle round, the square root out), in four layers of 75 fish 1.1 m apart, over a disc 16 m across. The disc is centred on the last school record uw_world writes, and all of it lies under the camera's way.

Each fish finds its closest approach to the path from the nearest of 26 of the path's samples in the placement's buffer (binding 0) and how far along the next segment it lies. From 1.5 s before that moment it darts away from the path at right angles, by 5.5 m less a fifth of its distance from the path. An outer fish starts 0.15 s sooner for every metre out, so none catches up with another. From 2.5 s after, once the camera has passed, it drifts back. Each fish heads where it moves, on top of a common swim, and its model matrix is built in the shader.

We measured the school offline over the act, with a copy of the shader's maths in 0.01 s steps. The fish keep 5.55 m from the blob's centre, 5.1 m from the camera, 1.96 m from every prop's reach and 0.98 m from the circling schools' fish. As ellipsoids of a fish's length and height, they never overlap. The school is one instanced draw, made only past story second 60 (119.9 s) and only while its disc is in the frustum. It appears unseen, with the camera turned 136-176° away. It casts no shadow, since that would cost the whole draw again. It costs 4.4 ms a frame at 150% on the UHD 620 with the school in view and 9 ms inside it.

The crabs (sculpted, drawn with the fish PBR shader) are small, reddish and eight-legged, with no scales. They turn up on the floor in the second half of the act and are kept clear of the boulders.

The whale (sculpted, posed by fish.vert, painted by whale.frag) is a blue whale about 30 units long. Its body is a loft of cross-sections. There's a broad, flat, U-shaped rostrum with the throat sagging below it, the deepest girth just behind the flippers, and then a long, slender tail stock, flattened side to side. It has swept, notched flukes, two slim flippers thick enough to show edge-on, and a smooth back with no dorsal fin. The vertex shader swims it the way cetaceans swim, with an up-and-down beat. A slow wave runs from head to flukes, growing down the tail stock, and the normals bend to follow it.

The skin is painted from the rest-pose position (the angle round the body and the distance from the flukes to the snout), so it moves with the animal. It's countershaded blue-grey, mottled with lighter spots and darker blotches. Long throat grooves run back from the chin, the mouth line sweeps down to a small eye, and the blowhole is on top. The baked skin texture adds fine relief and roughness as uReal rises.

The whale makes one slow pass in a lane of its own at z -42, which the props and schools keep clear of at all times. So it never touches the blob, the rocks or the fish. The pass runs 150 m along +X from WHALE_IN to WHALE_OUT, story seconds 4 to 44 (73.1-107.1 s of the show), about 4.4 m/s. It's high in the water, 3 m up at the top of its arc and 5.5 m under the surface, and it comes and goes out of sight and out of the sun's map. It first shows at about 76.5 s, some 90 m off, coming into the upper half of the frame at its left edge as the water clears. It drifts across above the blob's trail, from three-quarters on to nearly side-on. At the held glance up at 91.8 s, the camera is about 48 m from her centre (see The water's light). It's left behind as the blob turns away: she is still visible around 95.3 s and out of frame by about 97 s. For roughly 20 s she is the centre of attention. Where the whale can be seen depends on the blob's heading, which the camera follows, more than on the whale's own timing.

Seen that large at 1080p, three of its details need care. The throat grooves fade out as they shrink toward 4 pixels apart (fwidth 0.1-0.25), since finer grooves crawl as a knitted grid of bright dashes. The caustic web is at 0.4 on the whale and off on its fins, because seen from below, the web's cells line up along the curved back as evenly spaced dark bars. And the fins keep the flat diffuse look (mix(flatc, lit, uQ × body)). The near flipper, seen end-on from below, would otherwise catch the IBL's grazing sheen and the rim as a pale, stair-stepped teardrop at its root. Instead it shows as a soft, lighter patch on the flank.

The predator (sculpted, drawn with the fish PBR shader) is a big, lean, menacing fish with a forked tail and a tall dorsal sail of spines with a zigzag membrane. It's dark, scarred and pale-bellied, with pale, glowing, slit-pupilled eyes. It has no snout, and its front ends where its jaws begin. The two jaws are deep and rounded, the lower one longer (an underbite), and each has four long, uneven fangs a side, raked back. The upper fangs sit on the rim's inner edge and the lower ones on its outer edge, leaning out, so with the mouth shut they cross outside the upper lip. On the middle of their rim, the lower fangs' tips would lie by the upper jaw in the rest pose and take its bone, and posed they'd stretch into bars across the mouth. The jaws open on a wet, near-black gullet.

The kit cuts the body at the hinges, sculpts each jaw shut as a hollow shell and opens it to its rest gape the same way fish.vert swings it, so the jaws close the way they were made. uGape swings the upper jaw and its fangs up and the lower jaw down about those hinges (pred_gape). While the predator stalks, the jaws are ajar at the sculpted pose, 0.55, with the fangs on the rims. From a second before ENC_LUNGE to ENC_PEAK - 0.35 (120.9-122.6 s of the show) they're flung open to 1.55 (66° each), a tall dark maw ringed with fangs. The predator sweeps past the lens with them wide open, its maw filling the frame at the near miss (122.9 s), and they slam shut on the near miss's kick, from ENC_PEAK to 0.15 s after it. Opened only to 1 (43° each), the jaws look like a toothy box, and shut any sooner they close before they fill the frame.

A vertex within 2 cm of a jaw's hollow is marked as inside the mouth by adding 256 to its bones word. fish.vert reads the two bones from the low bits and passes the mark on, and fish.frag paints such a vertex as the gullet, a wet, near-black red with no eye decal, and cuts its lit colour to 15%. So the water's sheen, rim and ambient light don't light the inside like the hide, and the open mouth is black under the fog. The earlier 64,365-byte version was checked against the posed mesh every 5 ms, with minimum jaw and whole-body clearances of 2.08 m and 0.61 m respectively. Those are historical full-mesh measurements, not new measurements of the fitted path.

The current predator path is fitted to the original rounded release's fixed chase, rather than simulated at startup. It has 33 adaptive cubic Hermite knots: positions in 1/128 m as signed 16-bit integers, velocities in 1/4 m/s as signed bytes, and 32 span lengths in 60 Hz ticks as unsigned bytes. The tables occupy 329 raw bytes. pred_build converts each segment's tangents to the existing Catmull-Rom evaluator and reconstructs the same 60 Hz path table that the rendering and seabed placement use.

A knot at story second 64 preserves the near miss's timing. The fitted release path deviates by at most about 6 cm at its centre and 1.23 degrees in heading from the old rounded release; banking can differ by about 5.9 degrees. This preserves the stalk, lunge, miss, chase and break-off, with no steering or collision-push solver in the shipped path builder. Clearance checks sample three spheres along the body at 256 Hz, and the placement shader keeps props away from the reconstructed path. The camera blow, cold desaturated darkening and vignette retain their original cues. The fit is an approximation of the release animation, not a claim of identical frames or full-mesh clearance.

algae.vert / algae.frag draw the seaweed, a two-sided ribbon of 16 segments that tapers to a narrow tip, sways in the current (more at the tip) and runs from dark to bright green. The ribbon is built in algae.vert from gl_VertexID, and the mesh is only a count: the 32 triangles of a 17x2 strip, with triangle t on vertices t, t + 1 and t + 2. The spine sways through the instance matrix. The tapering width is laid across it in world space, square to the eye, turning about the spine like a cylindrical billboard, with the normal horizontal across the face. So a blade is never seen edge-on, where it would thin into a sub-pixel stick that crawls under the jitter. A blade 0.24 m wide at its root is about 4 px wide at 40 m. Each blade is scaled by its instance. Blades sprout from the floor at staggered times and ease up to full height, so more weed turns up as the journey goes on. A wrap-lit subsurface glow and a wet sheen come up with uReal.

A tall blade (from 3-5 m up, by its instance's height) is a kelp frond, up to about 0.9 m across its middle, with a rippling edge. It sways three times as far and is tinted golden brown, and algae.frag's translucency takes the tint too. It still turns to the eye about its spine. The thickets' kelp is 6-11 m tall and some cells double their loose blades to 3.2-6.4 m, rising toward the surface. The placement tests each blade over its height and sway, which keeps the kelp clear of the camera and of the blob. Kelp over 3 m casts into the sun's shadow map through shadowalgae, which is algae.vert with shadow.frag.

coral.vert / coral.frag draw coral in four forms, built in coral.vert from gl_VertexID. The placement picks the form for each head (aColor.a, about a quarter each). The staghorn is a short trunk forking four ways, and each fork forks twice more, which makes 29 tapered six-sided tubes of 36 vertices, 1,044 in all. Each child starts at its parent's tip with the tip's radius, so the joints overlap. The other three forms are one surface of revolution built from the same 174 quads, 16 sides round by 10 rings. It's an ellipsoid with its lower half pulled down onto the sand, by the sixth power of how far below the middle a ring lies, and two waves round its rim to make it irregular. From it come a brain coral's half-sunk dome, a table coral's plate (a tenth of its size thick) on the cone of its stalk, and a sea fan's thin upright disc. All four stay inside the unit reach the placement gives a head, so every clearance holds, and all cast through the one shadow program (shadowcoral). A staghorn alone would read as a sprig at flight speed.

Each head is turned and scaled by its instance and carries its own shade in its colour, as rock.vert's foot tint does for the boulders. Whatever faces down, like a table's underside and stalk or a dome's foot, falls to 0.3 of the colour. The whole head darkens toward the sand, to 0.4 at its foot, and the heads vary in lightness by a factor of 0.7-1.2. A head's hue is one of seven saturated ones: pink, orange, purple, yellow, teal, red and rose (the water takes red first). On a table the hue is muted to 45% and the rest is the table's grey, warmed, which gives olive, ochre, dusty purple and rose. A table's growing rim is paler. On a dome the hue is muted a little, to 80%, and on a fan not at all.

coral.frag lightens the upper parts by the height up the head, which vColor.a carries along with the form. On the shared PBR model it adds a polyp speckle (0.75-1.25 of the albedo, a dotted top up close), detail normals and a subsurface glow. It cuts a fan into lace where a 3D noise strays from its middle, and ridges a dome with meanders, the bands of a sine of a noise. The pigments also fluoresce faintly in the blue light, at 0.15 uQ of the albedo squared, so the reef keeps its colour further into the water. Much more than that, and the tables become flat, evenly lit neon discs. Heads grow in from a point as the blob flees into the richer water. They add about 1-2 ms a frame at 150% on the UHD 620 through the flight.

The blob is Scene 1's (blob.vert / blob.frag, see The blue blob), and as the renderer grows up it turns into jelly. That's driven by uQ, the act's renderer-evolution ramp, which runs from 0 at the breach to 1 at story second 30 (69.7-95.3 s; see The renderer evolves). Once uQ passes 0.1, at 74.6 s, the blob is drawn last, after the seabed, the water backdrop and the moon jellies. Just before it, the demo copies the picture drawn so far into a texture (jelly_copy, texture unit 9), the whole frame in one glCopyTexSubImage2D. A rectangle round the ball wouldn't save much, because the lens reads up to about 2.3 radii from the ball's centre, so the rectangle would be most of the frame anyway. The copy takes about 0.3 ms on the UHD 620 at 1536x864, and next to nothing on a compo machine.

The jelly is a clear ball lens. Each colour's ray is bent into the ball, crosses its chord (2 R cos θ) and is bent out again. The exit normal is the entry normal reflected about the ray, so the shader needs no centre. The copy is read 1.2 R beyond the exit point, so the reef behind shows through magnified and upright. Along that chord the blue body absorbs red and green by Beer-Lambert. A ray straight through the middle keeps e^(-1.2 (1 - c)) of each channel, where c is the body's colour, (0.15, 0.40, 1). Only a tenth of the milky shading remains. The ball's relative index is 0.88 (an index of 1.136 against the water), and each colour's index differs from the next by 0.004 times the Fresnel term. So the colours split a little toward the rim and not at all face-on. Split across the whole face, they would break each magnified caustic line into red, green and blue contours, like an oil slick. A Fresnel reflection mirrors the water around it, bright above and foggy below, with the sky contribution scaled by 2.6. The sun makes a broader, dimmer glint (pow(..., 300) * 4), so small changes in the skin's normal do not make it flicker as sharply. The caustic web ripples over the top of the ball.

While the blob is lumpy (uWobble 1, until the transformation rounds it out over 129.1-139.7 s), each lump is a small lens of its own. At full strength the lumps would focus the seabed's caustic lines into concentric blue rings across the body, like thumbprints. So while it's lumpy, its rays bend by a normal halfway between the surface's and the view direction. Once it has rounded they bend by its own normal (0.93 of the way there at uWobble 0.15), and the seabed shows through as clear, warped glass. In the flight the lens shows the rushing seabed, magnified and changing every frame. Measured at about 150-152 s, it changes no faster than the seabed beside it (24 against 28 levels a frame at 30 fps).

The jelly's share J is smoothstep(0.1, 0.5, uQ) squared, so it's only a quarter at the halfway point. With an even blend, the dark seabed seen through the lumps would show as dark blue bruises in the half-milky body. Squared, the milky body holds until the jelly can show clearly through it, and the change still finishes on time: J reaches 1 when uQ reaches 0.5, at story second 15 (82.4 s).

Until the end of the transformation the face is turned to the camera. The sun's glint has its half-vector just above the point facing the view, so it would sit on or between the eyes, like a third eye or a white nose. So there's no glint within about 37° of that point, and it grades back in by 53°, scaled by how much of the eyes shows. render_scene2 works out how far the face is turned from the camera and sends the eyes' share in uGridFade, Scene 1's grid knob, which is unused under water. This way the glint also leaves the face when it glances back in the flight, and returns when the back of its head turns to us.

The blob writes depth with gl_FragDepth. As jelly it writes the depth of its centre. While it's milky (until 74.6 s) it writes the depth of a point half its radius in, because with the centre's depth the TAA would leave a ghost of its rim inside its edge. The bubbles, its eyes and the marine snow draw after it, so they aren't in the copy. That way the eyes, 0.9 of its radius out, show through its front half however the lumps lie, and the lens never smears ghosts of them across the body. While it's milky, trail bubbles and specks of snow within 1.2 radii of its centre aren't drawn, since they would show through it.

As a lens, the blob casts no shadow, but it focuses the sun. uwsurf.frag works out that light from the ball's centre and radius, which ride in the Frame block's uGlow and uGlowAmt, two fields Scene 2 has no other use for. Scene 1's object shader, which draws Scene 2's bubbles, eyes and marine snow, uses the same two fields for its glow at the origin. So the block is sent again with uGlowAmt 0 just before that draw. Otherwise the specks would be lit by a "glow" coloured by the ball's coordinates, negative channels and all.

Sunlight through a ball of index 1.136 converges about 4.2 radii behind its centre (f = n R / 2 (n - 1)). A soft-bodied ball with a wobbling skin focuses loosely, so the sand under it gets a soft Gaussian spot (1.2 radii across at 1/e²) of up to 2.65 times the sun's light, carrying the caustic web. It sits in a soft, dim penumbra (0.65 at its centre, back to 1 by 1.1 radii). It fades in below the ball, fades out again as the ball rises 3-7 radii above what it lights, and fades out beyond 20-45 m from the eye. This applies to the direct light on the seabed and the boulders, and fades in with uQ like the shadows. At 1.5 times the sun's light, the spot wouldn't show over the web and the sky's light. The fish, coral, weed and whale don't get it, but they rarely pass under the ball.

The blob has no face through the journey and the whole encounter, so the stalk, the near miss, the bolt and the chase all play on its body alone. Scene 1's eyes (blob_eyes, 0.9 of its radius out) only grow back once it has survived the scare. They grow from nothing at TRANS_IN (129.1 s) to Scene 1's size over 9 story seconds (to 137.4 s), wide open, while the camera circles the blob.

The face is turned by an angle with no roll. Until the flight it turns toward the camera, tilted to the camera's height, and the hand-over turns it the short way round. In the flight the angle comes from the direction to the camera alone. It never comes from the blob's heading, which weaves faster than the chase camera, so a turn measured from it would whip round as the heading crossed the camera's line. The face looks away, toward the side the chase's sway swings the camera out to, and as the sway peaks it glances back to a tenth of that angle, about 18° off the camera. The eyes shrink away while the face is 23-50° from the camera. The camera is close, so the outline it sees lies about 75° round from it, and the eyes sit about 25° out from the middle of the face. Every appearance and disappearance takes 0.27-0.33 s, and while the eyes show, the face never turns faster than 3° a frame at 60 fps.

The bubbles are more instanced balls: the 14 rising out of the top of the blob and the dive's 40. The blob's bubbles are offset -1 to 1 along its heading, so they rise out of it and don't trail back between it and the lens. They carry alpha -4 (see Lighting (object.frag) for the codes), and object.frag shades them as air in water. Past the critical angle, where the view meets the skin at a sine over 0.75, the water's light is totally reflected. So the rim, graded in from a sine of 0.6 to full at 0.8, is a silvery mirror of the bright water around it: 3 times the fog's colour below, 7 times the light from above. With that grading, a bubble only a few pixels across still shows. Inside, they're clear apart from a sheen that keeps 20%, so the picture behind shows through, and the sun glints off them. render_scene2 draws the ball batch blended and premultiplied, after the jelly, so the jelly shows through the bubbles too. Everything else in the batch has alpha 1, so the eyes and the snow stay opaque. The dive's bubbles are 0.7-1.7 cm across per metre of distance from the lens, so they stay a few pixels wide as they rise past it.

The marine snow is instanced balls too: 500 specks of silt (5-18 mm) in a dim grey-teal with a touch of emission. They hang still in the water in a 10 m box that wraps round the eye. A speck shrinks away within 1.5 m of the lens (a smoothstep over 0.4-1.5 m on its size), since one passing 0.2 m from the lens would fly by as a white egg 120 px across. The backdrop has specks of its own, but they're fixed to view directions on the far plane, so they only show against open water and never move against anything. The snow hangs in front of the seabed, the rocks and the blob. It slides past with parallax as the camera trails the blob, streaks under the motion blur in the flight and goes soft in the depth of field. It's hard to see in a still and clear in motion. The specks take their own seed. The dive's burst draws from the bubbles' stream only while it lasts, so sharing that stream would move every speck when the burst ends. The 14 + 40 + 6 (two eyes, their lids and catchlights) + 500 instances stay within the ball mesh's 694.

Between the whale and the predator, at story seconds 40-55 (103.7-116.2 s), the blob would otherwise cross nothing but sand and boulders, in the same framing. So a swarm of 56 moon jellies drifts in the light above its path. jelly.vert builds each one from gl_VertexID. There's a bell of 16x6 cells on a flattened dome, with its rim drawing in and out about every 1.6 story seconds, and there are 12 strands of 10 segments, turned to face the eye. Eight are fine tentacles from the rim and four are broad, frilled oral arms from the middle, and all of them sway. Each jelly is tilted its own way, by up to about 15°, and its bell is 0.9-1.6 m in radius. jelly.vert places it by gl_InstanceID, 4-12 m to one side of the point on the blob's path (in uwplace.comp's buffer) that the blob passes at that jelly's own moment.

jelly.frag adds it over the water, on both sides and writing no depth, from story second 36 to 57 (100.4-117.7 s), fading in and out over the first and the last 3. It draws the clear tissue, which shows where it's seen edge-on, the rim and four pink horseshoe gonads round the crown. They're lit by the sunlight left at the jelly's depth and dimmed by the water's extinction with distance. The light the water scatters is already drawn behind it.

Eight cyan radial canals run out across each bell, with faint light on the trailing strands. Their glow pulses slowly with a phase that travels outward, and fwidth softens the fine lines at the pixel scale. That derivative is evaluated before the bell/strand branch so its footprint remains valid. The glow rises over story seconds 38-43, holds through 51 and fades by 56. Over the same envelope, the water's scattered-light colour dims by up to 30% and exposure drops by 0.10, so the canals show against a quieter background. This uses the existing jelly draw and bloom; the 56 jellies keep their geometry, paths and clearance.

The jellies' height keeps them clear of everything else whatever the hash gives, which matters because sines differ between GPUs, so the layout may too. At story second 48 the bell's centre is 3.9-5.9 m up, and it rises 0.1 m a second. That keeps its crown 0.8 m under the surface and the tips of its arms at least 1 m above the camera, the blob and the schools' fish. None of those rises above -0.8 m from story second 34 to 58. We measured every anchor, side, distance and height the shader can pick. One of the load's warm-up frames (half bar 105, at 101.6 s) draws the jellies, so their program is built during the load.

The seabed is a large, finely subdivided heightfield (mc_mesh_terrain's, computed on the GPU) sunk well below the blob. The boulders are a dense ball displaced by three layers of noise into craggy rock. Both are computed once at load by the shader that then places the props.

Every boulder, weed blade, coral head and crab in the act is placed once at load by a compute shader, uwplace.comp. It works against one buffer that holds everything the props must keep clear of. That's the blob's whole path (which is deterministic), the picture's camera (camera_uw) every quarter of a story second, the predator's path, the fish schools and the seabed's heights. A candidate's id says where it may stand. The 240 m seabed is split into 34x34 cells with 48 slots each. The current recipe uses two slots for fill boulders, six for weed and three for coral around a shared clump. Slots 11-33 scatter a mix of loose boulders, coral, crabs and blades, using the four LOOSE ranges for their sizes and seed times. Slots 34-47 form late coral patches with one hue per cell. The recipe shares its placement and sizing code instead of giving each cell separate boulder formations, kelp groves, two-hue patches and age-dependent size variations. The scene's larger structures still come from 18 landmarks of 96 slots each: six rock outcrops, six reefs and six kelp thickets. A landmark reef uses 56-85 of its slots, three quarters of them coral heads ringed by kelp.

The shader runs in 21 passes. The first works out the sand and the boulder. The sand is the 201x201 heights of mc_mesh_terrain's fBm, with the engine's noise ported exactly. The boulder is a cube's six grids (20, 10 and 5 cells a side for its three LODs), pushed out by three layers of that noise, and each vertex gets the normal of the surface around it. Both stay in the buffer for the frames. object.vert builds the seabed from the heights and rock.vert builds the boulders from their vertices, so each mesh is only the indices of its grid.

The next pass sites the landmarks beside the flight one after another, each with room for an outcrop's core and each born unseen once the predator has gone. Each site tries up to 99 points.

One pass seats every candidate on the sand by replaying the seabed's triangles. It keeps a candidate if it clears the blob's path and the fish schools, including the big school's whole disc, 12.5 m round it and 3.5 m above and below. The middle's props must also keep out of the whale's lane. The fill is seeded from about story second 60, long after the whale has gone. A boulder must also clear the camera's and the predator's paths, and its radius leaves headroom for rock.vert's growth. A blade is tested over its height and sway, just as coral heads and boulders are tested as they stand, so a short blade may stand under the path.

Sixteen passes settle conflicts the same way placing the props one by one would. The middle's props come before the fill, boulders before coral, crabs and weed, and after that the lower id wins. The decisions are double-buffered, and they settle by about the tenth pass. The one exception is a head in a coral patch. It makes way for the middle's boulders, coral, crabs and weed, which are all there before it, though a blade may stand at its edge, at 0.9 of its reach. It also packs tighter itself, overlapping the other heads of its patch (0.2 of the two reaches, against 0.32 between other coral heads). So a patch forms one mound, and nothing that stood there before it has to go.

One pass sets the timing of every prop that's kept. Each prop grows in from the first moment after its seed time at which, for the whole grow-in, the camera stays more than 70 m away or keeps the prop out of a 60° cone (born()). The range is that long because the water clears early, and at a shorter range a boulder far off could be seen swelling up from a dot. A prop dies when a landmark grows over its spot. One that's never out of sight for that long grows in at its seed time if that's before story second 50, and is dropped if it's later.

A boulder seeded before story second 40 may be born from the start of the act. Without that, at 70 m they'd all be born late, and under the whale's pass the lower two-thirds of the frame would be bare sand. Over the first 3 story seconds, in the murk, out of sight means further than 25 m, since at clarity 0 the water passes only about a tenth of the light from 30 m away. A boulder born then has its birth set 3 s earlier, so it stands fully grown from the first frame and never visibly grows. That puts 9-11 boulders in frame within 60 m over 74-96 s. The price is a sparser early act, since some props come later.

The last pass works on 68x68 squares of the sand, 3.5 m each (half a cell). For each square it lists the kept boulders whose contact shade reaches into it, up to 16. They're stored as the places of their records in the buffer, which stays bound on binding 0 for the frames. The squares are half a cell wide to keep the lists short, since the sand reads its square's list at every pixel. The pass also works out the reef bed at the square's centre. That's how much bed is laid down by the heads of the coral patches, the landmarks' coral and every head born after story second 80, leaving out any head a landmark grows over. Each head lays down a disc that fades out from half its reach to twice it, wider the later the head is born (up to about 4.25 times for the last). And the pass works out when the bed may grow in. That's the first moment after the last of those heads is born at which the square, too, stays out of sight for the whole grow-in, by the props' own rule. If that never happens the square gets no bed, which is the case for a handful of squares.

The CPU reads the result back into one list of props, which uw_prepare draws in one loop (growth, death, culling and the boulders' LOD). The 25 circling fish schools stay on the CPU, and it's the props that keep clear of them. A 26th record holds the big school, which fish.vert places. All this takes about 155 ms of GPU time at load in the earlier 64,365-byte version, about 60 of it for the lists, since every square scans every record. That version held 4,337 props. The current integrated verification retains 4,916: 636 boulders, 725 coral heads, 277 crabs and 3,278 weed blades. It checks all 4,050 late growth intervals and the path, camera, fish, predator and boulder clearances. The revised population recipe changes the layout. Its 21 passes retain the path-clearance tests, ranked conflict resolution, offscreen grow-in search, landmark death timing, contact-shade lists and reef-bed generation. That version's clearance measurements and load timings should not be treated as measurements of this revised layout.

The camera's path runs through the ring of one circling school, 3.35 m round, coming within 3.5 m of its centre at 111.8 s. That school keeps its ring, so the props still keep clear of it, but it's drawn empty, or one of its fish would cross the lens. A school shows no fish if any of the camera's samples comes inside a circle a metre wider than its ring, and only that one does.

The fill is seeded from about story second 60 and the landmarks are born once the predator has gone, so the reveal brings in the biggest structures last. Meanwhile the counts of visible rocks, fish, crabs, weed and coral keep climbing right through the closing flight. Props are seeded up to story second 96 and the circling schools fill up until 98 (148.5-150.0 s). The blob speeds up and spirals outward too: blob_phase, plus a widening of its wander during the flight, makes it really go further and faster. So the picture gets more detailed and more crowded with life as the blob travels, and it ends on a fully populated reef that shows what the engine can do.

render_scene3 gets the scene's own seconds, 0 at SCENE3_START (154.8 s). The first bar is white. S3_J0 is the length of that bar, one BAR_S (1.935 s), and jungle seconds count from its end: c->j is the scene's time minus S3_J0, negative in the white. Every cue is a jungle time on a bar line, written as a whole number of bars: S3_UP is 7 bars, S3_REX is 27 and S3_END is 54. The shaders that time their own action count the same jungle seconds, from uTime and the common block's s3j0.

The clock is stretched once, at the top of render_scene3. The scene's seconds go through stretch() with S3_SEG and come out as the story's, which is all that the camera, the packages and the shaders ever see. S3_SEG pairs bars of the show with bars of the story:

The story ends up four bars behind the show, and from the beach's hush on it runs at the show's pace. Each change of pace is eased over half a bar. So from a quarter bar after S3_GAP on, show time is SCENE3_START + S3_J0 + 4 bars + j. That is 154.8 + 1.9 + 7.7 s + j, or 164.516 s + j. The Timing section explains stretch() and how the clocks keep to the music, and Scene 3's music lists the bars each beat falls on.

S3_HOLD is four bars of the story in which we stay crouched while the tyrannosaurus walks out of the picture. Every cue from S3_CLEAR on has it added, in scene3.c and in jo_blob.vert, jo_blob.frag, ju_ground.frag and the surf block. The shaders carry it as a number (7.74 s, or a time that includes it), so a change to S3_HOLD has to be made in all of them.

The work is split into eight packages. Each is one C file that scene3.c =#include=s, with one shader prefix and a manifest of its own programs:

Each package has make, draw and free hooks, except the ladybug's, which has only draw. s3_make places the trees and works out their detail, then runs the make hooks at load, and s3_free runs the free hooks. draw is called once per pass, with c->pass set to one of four values:

• S3_SHADOW, the still sun maps. uViewProj is uLightVP and uQ is 1, so shaders only do their cut-outs.
• S3_LIT, the picture.
• S3_CHAR, the characters' own sun map, drawn every frame. The ladybug, the tyrannosaurus and the blob draw their depth there the same way as in S3_SHADOW.
• S3_LATE, after the sky, for whatever has to look through the finished picture.

A frame runs in this order. light_frame writes the lighting terms into the Frame block. light_shadow draws the sky's radiance table, then the still sun maps if they haven't been drawn yet (a dev build redraws them every frame, so hot reloads show), then the characters' map. Then comes the lit world: the hero plant first (up close it hides most of the frame), then the undergrowth and the floor, the trees, the birds, the tyrannosaurus, what the blob carries, and last the sea, which is see-through. After that come light_sky and the late pass. The late pass draws the blob's jelly, which needs the sea and the sky behind it. The sea and wet sand reflect the sky in their own material shaders. light_volume adds the shafts, and light_post sets the grade and the depth of field for the engine's post chain.

Each package lists its programs in its own s3_<pkg>.def manifest. programs.def pulls in scene3.def, which pulls in the eight manifests, and the Demo struct gets one mc_shader field per entry from the same X-macro. So startup, hot reload, the link checks and the teardown all see the jungle's programs with no per-program code.

The jungle has no mesh files. Every trunk, leaf, blade, frond and bird is grown in a vertex shader from gl_VertexID and gl_InstanceID, and so are the floor, the sea and the blob. The ladybug's parts are squashed and folded copies of one small sphere, which jb_bug.vert also builds. The C side only decides where things stand and hands the shaders a uniform table. The tyrannosaurus is the exception: at load the creature kit sculpts it into a mesh on the GPU (The tyrannosaurus). The bark, leaf and sand tiles and the far forest's impostors are baked at load too (The trees).

The s3 common block is a stretch of GLSL that the jungle's shaders carry byte for byte the same, between two marker comments:

// ---- s3 common: keep byte-identical in every jungle shader (owner: s3_light) ----
...
// ---- end s3 common ----

The jungle shaders share it wherever they need the scene's lighting and world helpers; the bake (jt_bake.frag) and creature kit (jr.comp) do not. The light package owns the block, and a change to it is made in one copy and copied over the others. The block keeps every package in the same light. The context-mixing packer codes the copies for almost nothing, and genshaders.py stores the block once (genshaders.py). It holds:

• the Frame block, which every scene's shaders share (Scene 3's meanings for its fields)
• the samplers for the sun maps (units 3-8) and the sky's radiance table (unit 15), bound with layout(binding), so no C code sets them
• s3sea, the direction toward the sea, and s3j0, the white's length (S3_J0)
• s3h(), the floor's height
• s3shadow(), the sun's shadow at a point
• s3lit() and the s3light() macro over it, the lighting
• s3sky(), the open sky, and s3fog(), the air between the eye and a point

Shaders that time their own action count jungle seconds as j = uTime - s3j0, the same as scene3.c. They are the tyrannosaurus's walk and its prints, the blob's hops and trail, and the birds.

s3shadow() is a soft sun shadow whose filter widens with the distance to the blocker, so the canopy far overhead throws soft dapples and a leaf close by throws a sharp shadow. It reads the clearing's map, or the beach's map past the clearing, with four hardware-compared taps, each filtered over 2x2 texels. Beyond both maps the canopy is taken to let a fifth of the sun through, and the open beach and sea get all of it. That is multiplied by one tap of the characters' map, which lets uBlobFog of the sun through because the blob's jelly isn't solid. The characters' tap is offset by a turn hashed from the point, over a radius that grows with how far the point lies past the character's middle along the sun (uGape is that depth). So the shadow's edge blurs with distance, as light bent by the jelly spreads out.

s3light() is physically based. Its highlight is GGX with Smith's height-correlated visibility. Its diffuse is rough, using the energy-preserving Oren-Nayar model (EON, Portsmouth et al. 2024). That model is flatter than Lambert, brighter with the sun behind the eye, and adds the light that scatters more than once. The diffuse uses half of each material's roughness, so sand, moss and bark come to about 0.45. Going rougher would dim the sun's flecks on the trunks, which we see looking up toward the sun. On top of that come the yellow-green light that thin leaves let through from behind, the sky and bounce ambient, and an ambient sheen. The sheen is what the surface mirrors: under the canopy that's the dark trunks round the horizon and the lit leaves overhead, and on the beach it's the open sky. It comes from Karis's analytic fit of the pre-integrated GGX, times Lagarde's specular occlusion.

The terms conserve energy. The highlight and the sheen get back what single scattering loses on rough surfaces (Turquin's compensation, about 1 + 0.04 rough² for F0 0.04). The diffuse ambient gets what the sheen leaves, a factor of 1 - E. The ambient also takes the surface's own occlusion through Jimenez's coloured multi-bounce fit (s3am(c, alb, ao)), so bright sand and lichen turn less grey in their hollows. The screen-space occlusion doesn't know the albedo, so the share left to it is lightened the same way.

s3lit computes the shadow first, so that little else is live across its texture fetches. Computed later, it pushes programs out of Intel's SIMD16 mode. The lookup reads the sun's maps 3 cm off the surface on the sun's side, along the normal times the sign of N·L. The normal faces the eye, so without the sign a leaf, a feather or a wing seen from its shady side would read its own shadow and lose the light coming through it. With it, backlit ferns and low leaves glow yellow-green where the sun comes through them, and the macaws' underwings catch the light.

s3light() widens the roughness by the normal's screen-space variance, a form of specular anti-aliasing that keeps glints on far leaves from sparkling. Vertex shaders share the block but have no derivatives, so s3light is a macro over s3lit() that only a fragment shader expands. genshaders.py drops unused macros and functions from each shader, so the vertex shaders lose the lighting and whatever only it calls.

Inside the forest, s3fog() is a humid haze that thickens toward the ground. For the part of a ray that lies out over the beach and the sea, it is thin, bright sea air that scatters the sky's own light toward the eye. This gives aerial perspective: the far sea and the far edge of the forest take on the sky's haze, warmer toward the sun. s3sky(d) is that sky, the open sky's radiance by direction, read from a table that jl_atmo.frag draws every frame (Light). The sky pass draws it. The sea, the wet sand and the blob mirror it, and the sea air scatters it.

s3light() also keeps the ambient part of what it returns, and s3fog() turns that into s3a, the ambient's share of the final colour. Every jungle shader that lights a surface writes s3a in alpha, so the post's ambient occlusion darkens only that share and the contact shadows darken only the sun's.

The beach has a second shared block, the surf block, in the five shaders that have to agree on where the water is (The beach and the sea).

Scene 3 gives the Frame block's fields its own meanings, listed at the top of scene3.c:

• uViewProj / uLightVP: the camera and the sun (uViewProj is uLightVP in the sun-map passes)
• uCam / uTime: the eye, and the scene's seconds after the stretch
• uLightDir / uGlow: the sun's direction and radiance
• uSkyColor / uGroundColor: the ambient from the canopy and the floor
• uFogColor / uFog: the haze
• uTop / uBottom: the sky
• uWobble: the wind
• uClarity: the macro amount
• uReal: the beach part's progress
• uRim: the offset from the clearing's sun map to the beach's
• uSun: the offset to the characters' map
• uBlobFog / uGape: the share of the sun the character on show lets through (0.3 for the blob, 0 for the ladybug and the tyrannosaurus), and the depth of its middle in that map
• uQ: 1 in the sun-map passes, -1 in the impostors' bake, 0 otherwise

The sun has three depth maps. All three see the same sun over the same depth range, so a point has the same depth in each. A scale and an offset take a point's coordinates in the clearing's map to the others (uRim, uSun):

• The clearing's map, 2048² over a box 72 m across (3.5 cm texels).
• The beach's map, the same size, round a point 45 m out toward the sea. These two are still. A release build draws them only once, for a frozen moment half a second before the jungle opens, and the show draws them in its load's warm-up.
• The characters' map, 1024², drawn every frame (S3_CHAR) in a tight box round whichever character is on show. The box is 6 cm across for the ladybug, 14 m for the tyrannosaurus, and 2.4 m for the blob, or 3.6 m once it carries the parasol.

All three are drawn through main.c's shadow_begin and shadow_end, which Scene 2's sun map uses too. The Light section has the rest: the frozen moment, the gaps cut for the sun, the characters' colour target, and how the taps are filtered and turned.

The texture units are fixed for the whole scene and all bound once:

• 3: the characters' map's colour, how much of the sun each caster lets through (uSunT)
• 4-6: the three sun maps (compared)
• 7-8: the first two again, through a sampler that reads raw depth for the blocker search
• 9: the copy of the picture the blob's jelly looks through
• 10-12: the baked bark, leaf and sand tiles
• 13-14: the far forest's impostor atlas (colour and depth)
• 15: the sky's radiance table

The demo's 32³ noise volume sits on unit 1's 3D binding, which nothing else uses, since the post chain binds only 2D textures there. The shaders' value noise (vn3) is a single fetch from it. noise_make in main.c makes it first thing at load, so the bakes and the seabed's placement can read it too. After the scene is drawn, the post passes use units 0-6.

jl_sky.frag draws the sky as a full-screen pass on the far plane. It runs after the world, so only the gaps in the leaves pay for it. It draws s3sky, a limb-darkened sun disc, its aureole and its glare. There is no separate cloud pass or cloud history buffer in the current build.

The open sky is a planet's atmosphere and not a gradient. jl_atmo.frag marches it every frame into a 64x32 RGBA16F table on texture unit 15. The table's columns go by the angle round from the sun's bearing. Its rows go by the square root of the height above the horizon, so it's finest near the horizon, where the haze changes fastest. Everything that looks at the open sky reads the table through s3sky(): the sky pass, the reflections in the sea and the wet sand, and the haze over the beach.

After the physical scattering, the same table blends in broad, thin wisps from two smooth value-noise octaves. They drift slowly with time and stay near the horizon: they fade up just above it and out between about 7° and 17° elevation, with at most a 0.32 blend. This adds work only at the table's 2,048 texels, and the existing sky lookups put the same wisps in the sea and wet sand. They need no additional render target, history buffer or cloud shadow pass.

Each texel is a ray from the ground through the air in 24 steps, closer together near the eye, with Hillaire's 2020 constants:

• Rayleigh scattering (scale height 8 km)
• Mie scattering with a Cornette-Shanks phase (g 0.8, which gives the sun's aureole), 10% absorbed, with a scale height of 1.2 km. Its turbidity is the humid tropics': three times the standard in the forest, easing to the standard over the glide out toward the beach (uReal).
• ozone absorption peaking 25 km up
• the sun's light through flat layers (it stands 48° up)
• a small isotropic share for multiple scattering

The table costs about 0.05 ms a frame.

The sun's main shadow map is a fixed 2048² box covering 36 m round the clearing, with 3.5 cm texels. A second map of the same size (uShadow2, texture unit 5) covers the beach and the forest's edge round a point 45 m out. It sees the same sun from the same depths (60-260 m), slid across. A scale and an offset in uRim take a point's clearing-map coordinates to the beach map's, and s3shadow() reads the beach map where the clearing's runs out. Beyond both maps the forest's canopy is taken to let a fifth of the sun through, and the open beach and sea get all of it.

The sun and the casters stand still, so the release build draws both maps once, for one frozen moment: jungle time -0.5 s, the first frame the show draws under the white. Whichever frame draws them, the whole Frame block is set for that moment and then put back. That fixes the wind, the eye position that turns the cards and thins the curtains of lianas, and the beach part's clearing. So the maps come out the same whether the show, a still, a seek or the load's warm-up draws them first. In practice the warm-up does (see The demo as a case study). The dev build redraws them every frame so hot reloads show.

A 12-texel patch over the hero leaf is cleared to a depth just under it, so a fleck of sun lands on the leaf and the ladybug and a shaft stands over them in the haze. For the sun's maps alone (uQ), jt.vert also drops the crown cards within 8 m of the sun's ray through a point 2.5 m above the tyrannosaurus's stopping place. That opens a gap in the canopy, out of view above, and puts a pool of sun on its track, which it walks into out of the shade. From the forest we see it near its terminator, and without the pool its dark hide would be a flat cut-out. The same pool lights the top of the beach, so the foreground of the beach shots is part sun and part palm and crown shade. The maps are drawn once, so none of this costs anything per frame.

Things that move can't cast into maps drawn once. So a third map (uShadow3, unit 6), 1024², is drawn every frame (S3_CHAR) in a tight box round whoever is on show. That's 6 cm across for the ladybug while the macro rig is in, then 14 m round the tyrannosaurus's hips, then 2.4 m round the blob, widening to 3.6 m once it holds its things. The map has the same sun and depth range, slid across the sun's rays, so uSun takes clearing-map coordinates to it. s3shadow() multiplies in one tap of it, with its normal offset and bias scaled to the box. So the ladybug's feet, the tyrannosaurus and the blob cast real shadows on whatever lies under them, and on themselves. It costs 0.1-0.4 ms. With no one on show there is no pass, and every lookup lands outside the box.

The map has an 8-bit colour target too, which takes 1 MB. The characters' programs draw into it with one colour output, as they draw into the picture, so the driver reuses the builds it made at load. With a depth-only target, Mesa's Intel driver rebuilds each program at its first draw, and with a cold shader cache that drops a frame as each character comes on screen. In the sun's map their shaders return at once and write a constant, so the colour costs nothing. For the ladybug and the tyrannosaurus it's 0. The blob writes how much of the sun each part lets through (uSunT, unit 3): 1 for its jelly and eyes, 0.5 for its parasol's cloth and 0 for the rest of what it carries (see The blob ashore).

The jelly lets 0.3 of the sun through (uBlobFog, set while the blob is on show). Its shadow's edge softens with the distance past the blob's middle along the sun's rays (uGape), as the light the jelly bends spreads out. The soft edge comes from one tap, turned by the point's hash, which the TAA averages. The ladybug's and the tyrannosaurus's shadows stay opaque and sharp.

The post's contact shadows stay on round the blob. The jelly, its eyes and its drops write an ambient share of 1, and the contact-shadow pass skips any pixel at 0.999 and over, so they darken only the sand round its foot. There's no caustic focus in the shadow. The map is centred on the blob's steady line and not on its hops, so a focus would slide out of the shadow on every hop.

All three maps are compared in hardware (GL_TEXTURE_COMPARE_MODE, linear filtering), so each tap is a 2x2 filtered compare. A sampler object reads the two still maps' raw depths (units 7 and 8) for the soft shadows' blocker search, taking the nearest texel both when magnifying and minifying. The search's taps are turned by a per-pixel hash, so texture()'s implicit level of detail mostly minifies them. But in a quad where a cut-out leaf has discarded some lanes, the derivatives read whatever those lanes held, which is undefined. With linear magnification those pixels would switch filter at random, and Scene 3's frames wouldn't repeat from run to run (see Determinism).

s3shadow() turns its four blocker and four filter taps by a hash of the point's world position, and the trees' jlit() turns its two by the same hash. That looks fixed per point, but the TAA's jitter moves the point under each pixel every frame, and the hash is chaotic far below a pixel. So the turns change every frame (eight jitter spots, eight turns per pixel) and the history averages them. The trees' pair of taps sits 2.5 texels apart along the turned direction. Fixed taps would draw the map's 3.5 cm texels as stair-steps and double edges across the sun's flecks on trunks lit at a grazing angle. Turned, they give soft, round edges.

The soft shadows' narrowest filter is 0.0003 uv (0.6 texel), for a blocker within about 2.4 m. It stays that narrow so the contact shadows under close leaves stay sharp.

For the light shafts (jl_vol.frag), each view ray is marched through the haze in 24 steps at quarter resolution, against the sun's map, out to at most 50 m. The haze scatters strongly forward (Henyey-Greenstein with g 0.7, plus an isotropic share) and is thicker near the ground. A ray glows as the square of how much of it the sun lights. That's a stylised contrast, which keeps the real beams and all but removes the dappled veil between them.

The lit share is measured over at least 8 m of air. A short ray to something near, inside a beam, is lit all the way, so on its own it would square to 1. It would then take more veil than the longer, partly shaded ray past it, and a morpho in a sunbeam would wash out pale against the trunk behind it. So the stretch past the surface counts for the share only. Samples under the floor aren't air and count for nothing, so the floor and what stands on it keep their glow. The glow itself sums only the air in front of the surface, with its last step taken in part, so there are no contour bands.

Past the sun's map, where the canopy is unknown, the air counts as all but shaded. A little light there would give every distant pixel the same milky glow. The engine blurs the result depth-aware (mc_renderer_blur) and adds it at the grade (mc_post.vol_tex, vol) in gold: the sun's light times (1, 0.9, 0.65), scattering 0.24 per metre at the ground.

The haze (s3fog in the common block) is humid air lit two ways. From above it takes the canopy's green light, a deep teal-green in the shade (uFogColor 0.09, 0.19, 0.17) that gets brighter the higher you look. It also scatters the sun's light forward, so toward the sun it glows gold (uGlow × 0.012 / (1.3 - cos θ)², with θ the angle from the sun). The opening shots look into the light and so stand in backlit air, while looking away the haze stays cool and deep. It's dense enough (uFog 0.011 per metre, thicker near the ground) that the trunks recede in clear layers, each farther one lighter and closer to the air's colour. Out over the beach and the sea the air is thin sea air, which takes the sky's colour from s3sky().

The shafts fade out past the forest's edge, because the open air over the beach carries no veil. The current build omits the earlier version's 7,000 dust and pollen quads and their two shaders.

light_post sets up the engine's post chain (see The renderer and its post stack). The grade has ground-truth ambient occlusion in the wide shots (on each pixel's ambient share, with contact shadows on the sun's share), saturation 1.12, a light vignette and grain at 0.008. The exposure is 1.0 in the forest's wide shots, easing to 0.8 up close and to 0.8 again for the beach part. render_scene3 adds the reveal's glare and the take-off's swell on top.

Looking out from the forest, the exposure stays set for the forest, so the beach glows past the dark trunks and the tyrannosaurus is a shape against it. A tension envelope rises from S3_GAP (jungle 50.3 s) to S3_REX + 3 s (55.3 s), holds through the head turn, then fades from S3_SHORE (60 s) to S3_CLEAR (67.7 s). At full strength it lowers exposure by 18%, subtracts 0.13 from saturation and adds 0.18 to the vignette. Once the animal has gone and the camera steps out toward the trees' last row, the exposure adapts to the sun. It does so between S3_CLEAR (232.3 s) and 4 s after S3_BLOB (240.1 s), ending at about 0.42, while the saturation rises to 1.24.

The depth of field (mc_post.dof, focus) is the engine's quarter-resolution bokeh gather. The macro amount drives it, up to 32 px of blur at 720 lines on the ladybug, and it eases off in the seconds after the take-off. The focus is the distance to the ladybug. The gather opens small, bright points out of focus into soft, round discs: the sun in a dew drop behind the ladybug, the glints on its raised wing cases. It also spreads the hero plant's blurred stems and leaves over the sharp ferns behind them as the gaze comes down. How both work is told under the depth of field in The renderer and its post stack.

On the beach the lens lengthens, and the depth of field behaves like a long lens's. render_scene3 adds a blur at infinity that falls off as one over the focus distance: 0.015 × the picture's height / (focus × tan(fov/2)) pixels. It fades in over the blob's first 4 s, so the glimpse and the tyrannosaurus stay sharp. The focus is the blob's distance, so the blob is always sharp. Behind it as it waves, the blur is about 5 px at 1080 lines, so the surf and the horizon soften and the blob stands out. The sand at our feet softens the same way. In the last wide view it's about 1.5 px. The quarter-resolution pass runs through the whole beach act.

They're built from a few standard parts: band-limited (polyBLEP) saw oscillators, ADSR envelopes with exponential decays, and a Zavalishin state-variable filter, which gives low-, band- and high-pass at once.

• The kick is a sine whose pitch falls from 150 Hz to 48 Hz, with a 4 ms click of noise on top. In the jungle it starts at 95 Hz with a softer click, which makes it a frame drum.
• The hi-hats are noise through a 9 kHz high-pass, closed (40 ms) or open (180 ms), with velocities from the pattern and a slight alternation left and right. In the jungle the same voice is a shaker.
• The bass is a saw through a resonant low-pass. An envelope snaps it open on every note, from 130 Hz up to 2.7 kHz, and closes it again with a 90 ms decay. The finale and the jungle add a sub, a sine an octave under the bass.
• The lead is three detuned saws through a low-pass: a pluck in Scene 1 and a slow bell in the descent. Hook B and the coda add a second lead an octave up. Both feed a ping-pong delay.
• The pad is the chord's three notes, each on two detuned saws, the left one flat and the right one sharp, through a resonant low-pass on each side. Its cutoff is the arrangement's main sweep.
• The finale adds a snare, band-passed noise over a 190 Hz thump, and a supersaw: seven saws detuned by up to 1.9% and spread across the stereo field. The supersaw goes through a low-pass at the pad's cutoff, so it opens and closes with the arrangement. Even at 6 kHz its aliases stay about 55 dB under its harmonics.
• The jungle adds a six-tine kalimba. Each tine is two damped resonators run as rotating phasors: the note, and a fast-fading 6th partial. A new note takes the quietest tine and is added onto what it still holds, so nothing clicks. The kalimba feeds the delay too.
• The jungle also has bird calls, claves, cicadas and wind. A bird is a gliding FM sine with a soft attack, and it whistles, trills or gives a macaw's falling squawk. Squawks are likelier when the birds are busiest. The claves are a 2.55 kHz sine that dies within about 30 ms.
• The cicadas are band-passed noise buzzing at about 87 Hz, swelling separately left and right. The wind is noise band-passed between 500 Hz and 1.9 kHz as it gusts.
• The beach adds the surf. On each side, low-passed noise rushes up and draws back on a wave of its own, every 7.3 s on the left and 8.9 s on the right.
• The tyrannosaurus has footfalls and breath. A footfall is a sub sine falling from 95 to 36 Hz under a crunch of litter. Its breath is two longer, band-passed snorts centred at 750 Hz and a growl: a 48 Hz saw and noise through a 220 Hz low-pass, with a rasping 23 Hz tremolo. The growl rings out with an approximately 1.35 s exponential decay.
• The footfalls and the breath draw on a noise generator of their own, so they don't reshuffle the birds and the wind.
• A noise riser, band-passed noise whose centre climbs with its level, leads into the drops and makes the reverse swells.

The leads and the supersaw rest through the jungle, from bar 80 until the end card at bar 139, which keeps the jungle cheaper to compute than the dance tune.

The delay is a stereo ping-pong of three sixteenths, a dotted eighth (0.36 s), with a feedback of 0.42. The dry signal goes in on the left and the echoes cross from side to side.

The reverb is a stereo feedback delay network. On the way in, the send loses its lows below about 150 Hz, so the tail doesn't boom, and two of Freeverb's allpasses smear its attacks. Then come eight delay lines of 32-61 ms, all prime lengths. Each line is read at its end through a one-pole low-pass, standing in for the air's damping so the highs die first, and through a gain.

An 8x8 Hadamard matrix, done as three butterfly passes and scaled by 1/√8, mixes the eight outputs. It's orthogonal, so the mixing loses no energy, and every line feeds every other. The mix is written back with the send added. Each line's gain is 10^(-3 len / (rate × rt)), so all eight fall 60 dB in the same rt whatever their length.

Each length also wanders by up to 6 samples either way on a slow sine of its own, a fraction of a cent of pitch, and is read with linear interpolation. That keeps the tail from ringing metallic. The even lines sum to the left and the odd ones to the right. That gives two different mixes of one tail, so a mono send comes out as decorrelated stereo. The shortest line (32 ms) doubles as the pre-delay.

Each movement voices the reverb its own way (RVV), and the gains and the wander are updated every 64 samples. The damping takes the highs out faster than the rt, so the tails measure shorter (T20 from an impulse, by Schroeder's backward integration):

The pad, the leads, the supersaw, the kalimba and the birds go to the reverb at the section's space level (P_SPACE). So do the snare and the claves, the only drums that do. The finale's snare picks up the reef's dark tail, and more of it as the outro opens out. The kick, the hats, the bass and the ambience stay dry.

The song has 29 sections, and the arrangement is data. Every section's levels sit in one X-macro list, RAMPS, of 278 entries. An entry names a section and a parameter. It moves the parameter from a start value by some amount over a share of the section, in a straight line or along a smoothstep. A parameter that a section doesn't mention is 0 there.

The 18 parameters are the instruments' levels, the pad's cutoff, the riser, the reverb send and the depth of the sidechain pump. The list is expanded into six column arrays, one per field, because the packer codes columns of bytes better than rows of structs. It has more than 255 entries, so each section's first entry is a 16-bit index. Editing the arrangement gives the format.

The render loop works out the targets for every sample and follows them through a smoother of about 5 ms, so a level that jumps at a section boundary doesn't click.

The mix has two buses. The drums, the riser and the tyrannosaurus go to a dry one. Everything else, from the bass to the reverb's return, goes to a musical bus that a sidechain ducks on every kick. It ducks by up to 0.8 of the section's pump level and recovers over about 160 ms. Scene 1 and the coda pump lighter (up to 0.65) than the finale (0.8-0.85).

A peak limiter then catches anything over 1.1 at once and lets go over about 40 ms, so the full finale doesn't drive the last stage hard. That stage is a DC blocker and a tanh soft clip, which never goes past 0.92.

The levels follow the story. The pad carries most of what sounds between 120 and 300 Hz and lies under everything, so its level sets each section's loudness floor, and the quiet sections hold it low. The intro rises from 0.26 to 0.48 over its first 40% and holds there until the bang, where the build's 0.75 takes over.

Space and the deep sit at 0.5, and the deep sinks to 0.23 at its end. The revised tyrannosaurus sequence raises the warning pad from 0.45 to 0.65 at the beach's hush, then from 0.65 to 0.9 during the encounter, with extra pressure from a filtered-noise swell and increased pad brightness before the first snort. Its dissonant bass pulses stay present until the relief.

The following EBU R128 measurements describe the earlier 64,365-byte version, before the revised whale and tyrannosaurus music; they have not been remeasured for the current score. Measured with ffmpeg on the capture soundtrack (MC_CAP_AUDIO), the sections span 9.3 LU. The quietest are the intro (-19.3 LUFS), the deep (-17.6), space (-17.0) and the tyrannosaurus (-16.0). The loudest are the take-off and the wave (-10.0) and the finale's peak and outro (-10.7).

The current full song, including the whale reveal and revised tyrannosaurus sequence, measured from the normally linked release synth before the packed build's float rounding, measures -12.0 LUFS integrated with a loudness range of 6.4 LU. Its sample peak is -1.52 dBFS (0.839473), its true peak is -1.5 dBTP and its RMS is -14.23 dBFS. The rounded release's sample peak is 0.847487. Both full-song checks remain finite and bounded; within each configuration, rendering in different block sizes produces identical samples.

Scene 1 is a bright dance tune in A major, 26 bars long: intro 4, build 4, hook A 4, breakdown 4, hook B 7 and outro 3. Its groove is four on the floor, with offbeat sixteenth hats, a bouncy bass and a plucked lead on an arpeggio.

• The intro is sparse, with no kick and no bass. The pad rises from a whisper, the filter opens, the hats fade in and then the lead. A reverse swell, the riser over the intro's last 14% (about 1.1 s), leads into the bang and is cut on its first kick.
• The build brings in the kick and the bass, eases in the sidechain pump, and ends on a riser into the hook.
• Hook A is the full groove.
• The breakdown is a breather with no kick or bass, while the filter sweeps slowly back up. A riser leads into hook B.
• Hook B is the bigger reprise, with the lead doubled an octave up.
• The outro collapses back toward the intro. The kick, the bass, the hats and the lead fade out in turn, and the filter closes from 2.6 kHz to 280 Hz.

The timeline shows what happens on screen in each section.

The second and third movements score Scene 2's long journey (bars 26-80). The second, 18 bars in D minor, goes with the fall from orbit, the dive and the murky deep. The third, 36 bars in C major with its anthem held long, carries the scene from the clearing water into its faster, more realistic finale.

The second movement is the same sixteenth grid stripped right back. There are no hats, a slow bell replaces the plucked lead, the bass holds long roots, and the kick plays a half-time heartbeat. Its four sections follow the picture:

• Space (5 bars) is dark and drowned in reverb, with the pad held low at 0.5 under the bell.
• The dive (5 bars) fades the heartbeat in and lifts the pad from 0.5 to 0.88. It starts from space's level, so the dive's first beat has no step. A riser over the last 45% leads into the splash.
• The splash (2 bars) is the hit. The kick and the bass fall away, and the resonant filter closes from 3.2 kHz to 500 Hz.
• The deep (6 bars) is muffled and calm, its filter under 1 kHz. The pad is back at 0.5 and sinks to 0.23 over the last 40%, and the bell fades out. A reverse swell over the last 18% (about 2.1 s) leads into the third movement as the water clears.

The third movement is the finale. It's a four-on-the-floor groove with a backbeat snare, a fat supersaw lead, a sub and heavy pads, under the strongest pump. It has three sections:

• The build (7 bars) brings in the kick, then the hats and then the snare, over a rising sub and a riser. The pad and the supersaw share one cutoff, which goes from 1.2 to 3.6 kHz. In bar 50 a snare roll leads into the peak, eighths turning into sixteenths and swelling from 0.3 to 1.8 times a plain hit. Within that build, the whale reveal opens the music out from 88.1 to 96.8 s, strongest around 91.9-92.9 s. It raises the held pad and reverb space while easing back the supersaw, kick and hats. The C-major harmony and existing voices carry the swell.
• The peak (26 bars) has everything in, and it carries the whole finale: the predator's stalk, the chase, the blob's transformation and its flight. The cutoff holds 4.2 kHz through the first half. Through the back half, from bar 64, it opens to 6 kHz over a riser that climbs to 0.7.
• The outro (3 bars) resolves and tails off. Two beats of snare sixteenths lead into it in bar 76, as the riser tops out. The cutoff closes from 4.2 to 1.5 kHz and the reverb opens out. Over the last 2.5 s (from 57% of the outro) a riser swells as the picture burns out to white.

Two things happen inside the peak without being sections of their own: the stalk and the swell.

The stalk is bars 60-63 (116.1-123.9 s), from just before the predator appears to the near miss. The anthem drops to a heartbeat. The supersaw goes out, the pad's filter shuts to 500 Hz, and the sequencer plays the second movement's pattern rows. That's the half-time kick and short roots on the bass and the sub, with no hats and no snare.

The kick on bar 63's third beat, at 122.903 s, lands 5 ms after the near miss. From 123.39 s, as the blob bolts, a beat of swelling snare sixteenths plays alone, and that's the drop. On bar 64 everything comes back at once with the filter open again, and the chase gets the full anthem.

In the code the stalk is an override. For those four bars arrange() zeroes the supersaw and sets the cutoff, and on_step picks the second movement's patterns, while the chords and the reverb stay the finale's. A section of its own would split the peak in three. It would also shift every section number that the arrangement and the jungle index by, and move the peak's ramps, which run in percent of the peak.

The swell runs over the peak's last quarter, from bar 71 (137.5 s, 2.2 s before the blob takes off) to the outro's downbeat (149.0 s). The supersaw itself swells from 1.0 to 1.4, so the flight lifts on the anthem. It's there because the opening filter alone makes the supersaw brighter rather than louder. On the downbeat the supersaw is back at 1.0, the riser cuts, and the cutoff drops from 6 to 4.2 kHz.

Scene 2 shows the picture, and Scene 2's story clock how its cues meet these bars.

The fourth movement (bars 80-139) is a warm piece in D major. Open, rootless sevenths (Dmaj7 / Bm7 / Gmaj7 / A add9) sit over a deep, ringing bass, and a kalimba plays a syncopated line through the chords. The groove is hand percussion: the kick becomes a soft frame drum, the hats a shaker, and the snare's row claves in a 3-2 son clave.

Cicadas, wind and bird calls fill the forest, and the surf the beach. The music darkens for the tyrannosaurus, lifts into A major for the blob's return, and ends on a IV-V7-I cadence. Its 15 sections:

• The white (1 bar, BARS_WHITE) is weightless. The finale's riser dies away, the pad opens, and high, bell-like tines ring long. Wind and cicadas fade in, so we hear the forest before we see it.
• The look round (8 bars) begins the forest at BAR_WOODS (bar 81), which is Scene 3's S3_J0. The filter settles warm, the cicadas swell and the first birds call. The bass, the shaker, the frame drum and the claves come in one by one.
• The canopy (5 bars) brightens, with the birds overhead at their busiest: whistles, trills and macaw squawks. In the bar before it, the frame drum and the claves answer each other in a fill.
• The descent (3 bars) thins the groove out.
• The ladybug (8 bars) leaves the kalimba almost alone, an octave up, over a soft pad, the insects and a few birds.
• The take-off (1 bar) lifts everything on the dominant, A add9, under a riser.
• The resolve (1 bar) comes home to D as the ladybug vanishes into the light, and the groove starts back.
• The glide (4 bars) travels with the shaker, the frame drum and the kalimba in eighths, and the drums drop away toward the forest's edge.
• The beach's hush (1 bar), from jungle second 50.3 at the first sight of the sea, begins the warning: a low D-E♭-A♭ cluster replaces the airy chord, and the melody, birds and percussion fall away.
• The tyrannosaurus (8 bars) keeps the forest quiet beneath a stronger held dissonant drone. D/E♭ bass and sub pulses sound every two beats, tightening to every beat from jungle second 55.2 to 59.0 as the head turns. Pad brightness, level and a filtered-noise swell rise into the first snort. The dark harmony and pulse hold through the departure and the wait, until the relief at jungle second 67.7.
• The relief (2 bars) brings the forest and the waves back up on A add9, the pivot into A major, with the kalimba fading back after the tension eases.
• The blob (5 bars) comes ashore to Scene 1's hook. Its arpeggio and its A-E-F♯m-D progression are now on the kalimba, over the jungle's hand percussion and the surf.
• The wave (2 bars) holds on A while the blob waves, with a rising run of high kalimba notes each bar and the pad bright.
• The play (6 bars) comes in on a frame-drum-and-claves fill like the canopy's. It brings the groove back up and the sea louder, under Scene 1's hook.
• The end (4 bars) closes on D-E7-A, held on A, as the blob sits and the last wave laps at it. The pad, the kalimba, the waves and the forest fade out with the picture, and a short swell leads into the end card.

Some sounds land on the picture's own beats:

• Thirteen footfalls fall two beats apart from the tyrannosaurus's first bar (bar 112, 216.8 s), matching S3_REX and S3_STEP. They're heaviest as it passes closest, on the fifth and sixth.
• It snorts twice as it looks at the camera, peaking at 57.93 and 58.54 jungle seconds (222.45 and 223.06 s). The stronger throat growl follows as it turns away, from 58.9 jungle seconds (223.42 s), and decays through the departure.
• A soft, low pluck sounds under the blob's hops, 0.75 into the beat each one lands on (0.36 s), from bar 123 (238.4 s). All 25 hops that land on a beat get one. The jump into the swash lands between beats and gets none.
• The plucks come from one 64-bit mask of beats, which mirrors s3_blob.c's JO_RUNS.
• Each landing in the water also splashes, a hiss through the tyrannosaurus's breath filter. The seven splashes sit in a short table (SPLASH) of steps counted from bar 129, and the shiver on the dry sand gets none.
• The jump's splash starts at 93.15 jungle seconds (257.66 s), the moment the picture's blob lands.

The synth counts the jungle's sections, footfalls, hops and splashes in the song's bars after BAR_WOODS. scene3.c counts its cues in bars of a stretched story, which runs four bars behind from the hush on. So the footfalls, 31 bars after BAR_WOODS, meet S3_REX at 27 story bars, and the first hop's pluck, 42 bars after it, meets JO_HOP0 at 38. Scene 3's jungle clock has the stretch, and Scene 3 the picture.

The last five bars (139-144, 269.0-278.7 s) play Scene 1's movement again, under the end card. Its kick, hats and bass return, with the plucked lead and its octave layer on the arpeggio, over A-E-F♯m-D, and the last bar goes home to A. A reverse swell over the jungle's last 12% (about 0.9 s) leads in, and the coda comes straight in on the first kick.

On top, the kalimba sings the card's words as the blob lands on them, one note a syllable on beats 4-10: B E G♯ E F♯ C♯ A for HEL, LO, MI, CRO, COS, MIC and WORLD (END_MEL, in step with main.c's END_LAND). It plays a D for the somersault's landing on beat 14 and an A on the last downbeat, beat 16. Over the last bar everything dies away with the picture. The end card has the picture.

The picture never looks at the synth's state: no note events, no levels. It reads one number, the playback position, and times everything from it. Each frame, main.c takes its clock from mc_audio_time(), the seconds of the song that have been heard, so bar n of the song is at n × 240 / BPM seconds of the show. The master clock explains how the position is estimated and what happens without audio.

So everything that should land on the music is a time in bars. main.c defines BPM (124) and BAR_S, one bar of 240 / BPM seconds, and writes its cues as multiples of BAR_S. T_BANG, the first kick of the build, is 4 * BAR_S, and the scenes are 26, 54, 59 and 5 bars long.

For motion that follows the beat, mc_scene.h has the timeline helpers. Fill an mc_timeline with the time, the length and the tempo, then:

• mc_beats() gives the time in beats.
• mc_beat_pulse() gives a 0..1 pulse that jumps to 1 on each beat and decays, faster for a higher sharpness.
• mc_window_active() and mc_window_phase() switch a span of time on and give the 0..1 progress through it.

"Hello World" uses a smooth sine of mc_beats() for Scene 1's pulsing, because a hard pulse makes the motion stutter. It uses mc_window_phase() for fades such as Scene 1's collapse.

mc_timeline tl = { t, DUR, BPM };                               /* main.c's clock */
float sb = 0.5f + 0.5f * sinf((float)mc_beats(&tl) * MC_TAU);   /* a smooth beat */
if (mc_window_active(&tl, 4 * BAR_S, 4 * BAR_S)) { /* the build, bars 4-8 */ }

Cameras, tracks and beats describes the helpers, and the toolkit reference lists their calls.

Everything is in src/synth.c, most of it near the top:

The bass row holds semitones above the chord's root an octave down, and REST (127) means no note. The arpeggio row indexes the chord's three notes over two octaves (0-5), from an octave above the root. The movement's lead plays it: the pluck, the bell, the supersaw or the kalimba.

on_step picks the movement from the section number. Sections 0-5 and 28 play the first movement's tables, 6-9 the second's, 10-12 the third's and 13-27 the jungle's. The movement chooses the PAT and PROG rows, the envelopes, the reverb's voicing and the voice that plays the arpeggio.

A few other places count sections by number too: where each progression restarts, KAL4[sec - 13], JHARM[sec - 18], and sec > 24= for the kalimba playing Scene 1's arpeggio. Changing notes and levels inside the 29 sections touches none of this. Adding or removing a section means changing SEC_COUNT, renumbering RAMPS and moving these tests.

Two more things to know. In synth.c the S3_ and SCENE3 names (BARS_S3_BUILD, BAR_SCENE3 and the rest) belong to the third movement, Scene 2's finale, not to Scene 3. The jungle's are BARS_JUNGLE, BAR_JUNGLE and BAR_WOODS. And SEC_BAR and FILL hold bars in a byte, so a song can be at most 255 bars long, about 8 minutes at 124 BPM.

For a demo of your own, start with the events tied to "Hello World"'s picture, which you'll want to delete or retime. They're the stalk, the fills, the footfalls, the snorts and the growl, the hop plucks, the splashes and the coda's melody.

Two entries from RAMPS, one from the intro and one from hook A:

F(0, P_HAT|SM, 40, 60, 0, 450)   /* intro: the hats fade in from 0 to 0.45 over its last 60% */
LEVEL(F, 2, P_KICK, 1000)        /* hook A: the kick at full level throughout */

F(section, parameter, a, w, v0, d) moves the parameter from v0 to v0 + d while the section's progress runs from a% to (a + w)%, and holds it before and after. |SM makes the move a smoothstep instead of a straight line. LEVEL(F, section, parameter, v) holds v for the whole section. Levels are in thousandths, 1000 being the instrument's full level, and P_CUT is in Hz.

The parameters are P_KICK, P_HAT, P_BASS, P_SUB, P_LEAD, P_LEAD2 (the octave layer), P_PAD, P_CUT (the cutoff of the pad and the supersaw), P_SUPER, P_SNARE and P_PUMP (the sidechain's depth). Then come P_SPACE (the reverb send), P_RISER, P_KAL, P_BIRD, P_AMB (the cicadas), P_WIND and P_SURF. In the jungle, P_KICK is the frame drum, P_HAT the shaker and P_SNARE the claves.

Some rules come from the way the list is stored:

• A parameter the section doesn't name is 0 in it. Each section has to list every instrument it wants to hear, and the cutoff too.
• Keep the entries in section order, and give every section at least one. mc_synth_make finds each section's first entry by scanning the list, and arrange() reads from there up to the next section's first.
• v0 and d are each stored in a signed byte. Levels are kept in hundredths, so they have to be multiples of 10 from -1280 to 1270.
• The cutoff is kept in steps of 50 Hz, so v0 and d must each stay within 6.35 kHz either way, though v0 + d can go higher. Nothing warns when a value doesn't fit: the cast wraps it round.
• A ramp whose d isn't 0 needs a w above 0.

synth.c and main.c each write down the tempo and the song's layout, and nothing checks one against the other. When they disagree, nothing fails: the picture just lands off the music. These have to match:

• The tempo: SONG_BPM in synth.c and BPM in main.c, 124 in "Hello World".
• The scenes' lengths. main.c's SCENE1_DUR to SCENE4_DUR (26, 54, 59 and 5 bars) go with the synth's BAR_SCENE2, BARS_SCENE2 + BARS_SCENE3, BARS_JUNGLE and BARS_END, so TOTAL_DUR matches TOTAL_BARS.
• Scene 1's cues, T_BANG to T_OUTRO, and the synth's BAR_BUILD to BAR_OUTRO.
• The stretch tables, S2_SEG in main.c and S3_SEG in scene3.c, which change pace at the song's section changes. If a section changes length, the stretch has to change with it, or the cues after it slide.
• The events timed to the picture: the stalk and the predator's cues, the footfalls and S3_REX, the hop mask and SPLASH and JO_RUNS, and END_MEL and END_LAND.

Defined twice has the full table, and the times that the jungle's shaders carry as literals.

The song's length matters too. The release build exits when the clock reaches TOTAL_DUR, and the capture build writes that much audio and silences the rest. A song longer than the show is cut off there. A shorter one holds its last step and rings out while the picture goes on.

A tempo that differs shows as drift. At 1 BPM off, the show's last bar lands more than 2 s away from the music's.

A demo of your own can ask the synth for its tempo instead of keeping a second copy. mc_synth_bpm() returns SONG_BPM, and mc_synth_length() the song's length in seconds. The tutorial fills its mc_timeline from them. "Hello World" doesn't, because its cue times are compile-time constants.

Any src/synth.c that defines the five functions of mc_audio.h will do: mc_synth_make, mc_synth_free, mc_synth_render, mc_synth_bpm and mc_synth_length. A few rules carry over from this one:

• mc_synth_render runs on the audio thread, so it mustn't allocate, lock or do I/O. Allocate everything in mc_synth_make.
• It writes interleaved stereo floats at 44.1 kHz (MC_SAMPLE_RATE), each one finite and between -1 and 1.
• It has to render the same samples however the frames are split into blocks. The audio thread asks for 1024 frames at a time and the capture build for
• tools/checks/synth.c tests the last two rules over the whole song, and python3 tools/verify.py builds and runs it.
• In the packed build, library calls go through the hashed import table in include/microcosm/mc_imports.h. For maths it lists sinf, cosf, tanf, tanhf, expf, exp2f, powf, floorf, ceilf, acosf and atan2f, with calloc and malloc for memory.
• Add any other library function you call to that list, or the payload imports it by name, which costs more bytes. Include mc_imports.h after the system headers. The pipeline explains the table.

In the 64,365-byte version, before the current size reductions, synth.c took about 4.5 KB of its 61,026-byte stream in this tree's build, as codecost.py counts it. That's about 3.4 KB of code and 1.1 KB of tables. The biggest pieces are mc_synth_render (1.65 KB), on_step (0.62 KB) and the arrangement.

The arrangement's 278 ramps take 0.71 KB in their six columns, about 2.6 bytes each. The patterns take 88 bytes and the chords 40. audio.c adds another 0.44 KB. The synth's float constants sit in the shared constant pool and aren't counted per file. The current packed file has 2,299 bytes to spare.

In memory it takes 661,344 bytes, allocated once. Almost all of that is the delay's two rings of 65,536 samples (512 KB) and the reverb's eight lines (128 KB).

In time, the capture build renders the whole song in 8 to 10 s on the i7-8550U laptop, about 30 times real time. Playing it live takes about 3% of one core.