Contract/token: 0x71eb648bdd6ebb161dcda890dfadd1d28972ea42/41

Transmutation XLI #41 - Substrate Transmutation [SETHIX] by Iain Ball | OpenSea

Pure WebGL SETHIX modules

https://opensea.io

Is the successive replacement of the generative ground itself. Transmutation III displaced the vertices of a mesh. Polymorphic Lattice (XXXVI) abandoned vertices for an implicit field in an eleven-dimensional cubic coefficient space. ICOSA Morph (XXXVIII) changed the symmetry group from cubic to icosahedral and, with it, from periodic to quasiperiodic. Colony Morph (XL) built that same group by kaleidoscopic reflection into 1/120 of space, made symmetry itself a continuous coefficient, and governed the whole organism in measured units of rendered change.

Nodal Morph returns to the cubic lattice, and changes three grounds at once.

The domain becomes registered. In every previous module the body was a field evaluated inside an envelope — a radial shell, a lobed mantle, a bounding blob. The lattice lived inside a shape. Here there is no envelope in the primary regime. The body is a cut of the crystal: a rounded cube whose half-side is derived from the lattice's own period, so its faces land on lattice planes by construction, at every frequency, continuously, with no snapping and no scheduling. The silhouette is not a container that happens to hold a lattice. The silhouette is the lattice, terminated.

The frame stops being part of the organism. In prior versions the cage was a function of the creature: it tracked the bounding box, its subdivision order rose and fell with a coefficient, its hue drifted from red to violet, it gave way when a wrapping shell appeared. Here the cage becomes an invariant — one red 3×3×3 grid, one fixed extent, one fixed line weight, one colour, forever. All the complexity that used to live in the cage's parameters migrates instead into structure that grows within it: sub-grids, interstitial bars, and a registration grid whose lines sit at the body's own cell pitch. The frame stops being decoration that morphs, and becomes a constant the organism writes on.

And the module acquired a law discovered at the level of the GPU's shader compiler. Not a mathematical constraint, not a perceptual one — a hardware one, found the hard way, after the piece rendered perfectly in every test environment and drew absolutely nothing on the machine it was made for. That story is the centre of this article, and its conclusion now governs every SETHIX module: no derivative instructions anywhere in the fragment shader.

Every triply periodic minimal surface in the reference plates — Schwarz P, the gyroid, Schwarz D, Schoen I-WP, Neovius, F-RD — is a level set of a short trigonometric series on the simple-cubic reciprocal lattice. Five shells hold all of them exactly:

Verified to 1e-15. So an amplitude and a phase per shell is a continuous space containing every named surface and every hybrid between them. Everything between the named points is a valid unnamed higher-order surface.

The whole field costs sin and cos of x, y, z and about twenty-five multiply-adds: every shell is a product of the same six transcendentals, and the double-angle identity hands over the {200} and {220} terms for nothing.

The gyroid and its achiral shell-mate cos x cos y + cos y cos z + cos z cos x occupy the same twelve wave vectors at the same amplitude. They differ only in phase:

{110}(φ) = 2[ cos φ · B110 − sin φ · G ]      max error 7.1e-15
{111}(θ) = 4 cos θ · cosXcosYcosZ + 2 sin θ · D

Both pairs are exactly orthogonal — ⟨B110, G⟩ = 0.00e+00, ⟨4CCC, 2D⟩ = 2.8e-17 — at equal norms, so each rotation has constant RMS amplitude: the object does not thin or bulge as it turns.

And the phase is not a translation in disguise. Solving k·a = φ for every wave in a shell: on {100} it solves exactly (a = (φ, φ, φ)), so a phase there is a rigid shift and buys nothing. On {110} and {111} the residual is 1.0 — inconsistent — so those are genuinely new shapes. Turning φ from 0° to 90° carries the organism from achiral to the full gyroid; on to 270° gives its mirror image.

Chirality falls out of the mathematics as one continuous coordinate. Colony Morph had to bolt on a parity-signed twist with a bump gate to achieve the same thing without tearing. Here it is a coefficient like any other, and it cannot tear, because both endpoints are the same twelve waves.

Normalised to unit RMS, all five shells are mutually orthogonal to 1e-16, and so are the two phase partners inside each shell. The coefficient vector is therefore a genuine orthonormal coordinate system: moving one axis cannot secretly move another. That is what makes a perceptual metric over it meaningful, and it is why the shell norm can be held inside a band (0.34–1.62) as a simple projection — the field's RMS is the norm of the amplitude vector. Without that, a state with four shells lit is four times as steep as one with a single shell, and every threshold has to be retuned as it morphs.

The basis originally allowed only non-negative amplitudes, on the reasonable-sounding grounds that a negative amplitude is a phase flip. It is — but the phase axes only cover {110} and {111}. The {200} shell has no phase partner, and I-WP is {110} minus {200}. With a non-negative A4 the module could not express Schoen's surface at all; what shipped under that name was a different surface entirely, and it read as a bland lobed blob because it was one.

A4 was opened to [−1.10, 1.10] and every consumer of its magnitude — the Lipschitz bound, the fragility term in the shatter gate, the interest metric — updated to |A4|. The result verified against the closed form at the points that distinguish the surface:

A hub at the centre, arms along the body diagonals to the eight cage corners, corner hubs, and nothing along the edges or faces. That is I-WP.

The marcher divides the field by a bound on its gradient so the result is a conservative distance. The naive bound is Σ|a_k|·|k|. The shipped bound is the true supremum of |∇F| for each unit-RMS shell, from the analytic gradient on a 160³ grid, maximised over phase for the two rotating families, plus a 4% margin:

LIP = [1.471, 2.466, 2.942, 2.942, 4.804]

against realised gradients of 1.412 / 2.306 / 2.457 / 2.810 / 4.589 and naive bounds of 2.449 / 4.899 / 4.899 / 4.899 / 9.798. The shipped bound sits 1.04–1.20× above the realised gradient — tight — and is 1.67–2.04× tighter than the naive one, which is a straight doubling of the marching reach for nothing. (The source comment garbles which of those two ratios is which; see the honest notes.)

Here is the substrate change, in one line of shader:

glsl

float sC = P_CEL * 3.14159265 / P_FRQ;      // cells × π / frequency

The body is the lattice intersected with a rounded cube of half-side s = cells·π/frq. The lattice's period is 2π/frq, so a half-side of n·π/frq is exactly n half-periods: the cut faces always land on lattice planes, whatever the frequency does, and s moves continuously in both axes. There is no snapping step, no quantisation, no "nearest cell" logic, and no schedule. Registration is a property of the expression, not a behaviour of the code.

The cubic harmonic cub warps the cut — star, cross and concave silhouettes — and its Lipschitz share moves into the cut's own divisor, kc = 1 + 7|cub|.

Earlier passes at this module fixed the pinned landmarks and lost them again between the landmarks. The forms would leave one named surface, drift, and arrive as what the brief called "the compact radial blob family": a rounded object with some texture on it. Every screenshot that failed review was a live drifted state, never a pinned one. Polishing the landmarks could not fix it, because the problem was the domain — a radial envelope makes a ball with a lattice inside it, and between two well-chosen ball-shaped states you get another ball.

With the domain itself cubic-registered, the chunk read survives every hybrid. 15 of 15 sampled live drift states read as lattice chunks after the reset, which is the property every previous pass had lost.

The old radial envelope survives as a blended legacy mode on the cut axis: d = mix(dEnv, dCube, cut). A mix of two 1-Lipschitz fields is 1-Lipschitz, so the marcher is untouched. RADIOLARIAN sits at cut 0 — the one genuinely envelope landmark, a lobed shell with radiating spicules — SEED at 0.70, and everything else is a chunk at cut 1.

They are attractors in the space, not models: everything between them is a valid unnamed organism.

* I-WP is the one landmark the containment clamp actually touches: its authored s of 1.208 is reduced about 3% to 1.171 so the chunk cannot outgrow the fixed stage. Everything else authors below the limit.

A second, finer nodal field carves round perforations through the wall — the hierarchical organoid of the reference plates. It is folded into the lattice distance rather than intersected afterwards (max is associative, so d is unchanged), which means the surface net below is built on the finished, perforated sheet rather than on a wall that later acquires holes.

This is also where one of the quieter bugs lived. The carve compared a distance (≈0.04) against a constant retreat (0.18) — a unit mismatch, so the second scale never fired at any setting. Comparing field values instead (H < h2l + gg·0.28 − 2.4(1−h2)) turned it on, and the hierarchical landmarks became hierarchical.

"Make sure the red grid/cage it sits in is always uniform and the same size and colour (red) — at times under certain conditions it becomes more complex meshes and grid, like laser scanning through the lattice."

The cage before this brief was the accumulation of every previous module's cage ideas: a subdivision order that morphed with a coefficient, a fractional cross-fade between orders, a hue axis running red to violet, a term that faded the whole box out as a wrapping shell appeared, and an extent that tracked the body's measured bounding box every frame. All of that is gone.

glsl

float R = uCage;                              // constant: 1.25, forever
const float n = 3.0;                          // 3×3×3, always
float lineW = lw * 1.55;                      // fixed device-pixel weight
vec3 cc = vec3(0.980, 0.105, 0.090);          // red. only ever red.

Outer edges draw at full weight, interior planes at 0.82, and that is the entire frame. It is drawn as screen-space analytic lines — for each segment, the closest approach between the ray and the line gives the perpendicular distance (which sets a constant pixel width at any depth) and the depth of that approach (which tests against the body's own hit distance, so the near half of the cage crosses in front and the far half is occluded, with no depth buffer and no geometry).

The moment the cage stops following the body, the body must be made to fit. It was not free. The first build of the invariant frame leaked: five of sixty-four spike-free states put pixels outside, the worst at 1.145× the cage half-side — all of them drifted PERFORATE states, where a positive cubic harmonic bulges the cut's faces outward and the existing clamp knew nothing about it.

Three continuous mechanisms close it, in order of how much they do:

1. The chunk clamp learns the harmonic. The cut's Chebyshev reach is s · cubMax(v), where the harmonic bulges faces by (1+cub) for positive cub and diagonals by (1−⅔cub) for negative. So cel ≤ 1.21·frq/(π·cubMax(v)) rather than the harmonic-blind 1.21·frq/π. This is a projection onto a convex half-space whose position moves continuously with the coefficients, so it cannot oscillate.

2. The envelope gets its own clamp. Face-direction reach Ro·(1+lob/2)·cubMax·(1+0.55·blg) ≤ 1.21, relaxed smoothly as cut → 1 — because pure chunk states never evaluate the envelope, and clamping Ro there would distort the density gradient (which runs through Ro) of verified landmarks for no containment gain.

3. The stage cut. At the end of the map function, and mirrored exactly in the CPU field:

glsl

float chp = max(max(abs(p.x), abs(p.y)), abs(p.z));
d = max(d, chp - uCage*0.998);

The Chebyshev distance is 1-Lipschitz, so the marching bound stays valid. The body's own clamps keep it about 3% inside, so this bites only the surface net's silhouette overhang (which is allowed to stand proud of the body by three wire radii, up to ~0.075 world units at high cub) and any drifted transient. More importantly it makes containment true by construction for everything the map function will ever draw, including structures not yet written.

Measured in the renderer rather than predicted — a build whose fragment shader flags any hit point with |p|∞ > uCage:

0.996 is the point: the body reaches within half a percent of the wall and never crosses it. Snug, not caged at a distance.

All twelve landmarks render at exactly rCage 1.250 with the identical red frame.

Stage two of the brief was the scans — the frame briefly becoming a measuring instrument. Stage three was the note that mattered most:

"The idea is for extra grids, subdivisions, and interstitial lines to form within the grid naturally, in an emergent and seamless way, and in a way that's symbiotically connected to what the core lattice is doing."

An event that flashes and vanishes is not emergence. Three layers now grow inside the invariant frame, each weighted by a slewed function of what the organism is actually doing, all accumulating into the same accumulator and leaving through the same single red mix — so complexity varies and colour never does.

1. Interstitial half-bars. The 6×6×6 interior lines that are not in the 3×3×3, drawn thinner (lw·1.05 against 1.55) and dimmer (0.44×). Each line wakes on its own phase — 0.5 + 0.5·sin(slow clock + hash(i, j, axis)) — so the subdivision crystallises line by line instead of switching on as a set. That single detail is most of the difference between "a denser grid appeared" and "the grid is growing".

2. Face grids, on the six cage walls, with per-face weights drifting on the genotype's incommensurate clocks in metabolic time — so structure wanders around the cage rather than blooming everywhere at once. Two families:

• an interstitial order-6 grid drawn only between the main lines (fract(k) − 0.5 puts it exactly at the half-cells);

• the registration grid: lines at the body's own cell pitch π/frq. As the lattice tunes its frequency the lines glide across the walls; as cut leaves chunk registration they dissolve; and they fade themselves out before the pitch approaches a pixel and could moiré. This is the direct symbiosis — the frame reading the crystal it contains, in the crystal's own units.

3. Mid-plane meshes, faint and persistent, energised by the wake of a scan. A sweep leaves its axis's plane crystallised at 0.85 and decaying with a 7.5 s constant; a three-plane flash wakes all three at 0.50. The events now feed the standing structure instead of merely interrupting it.

cageDrive(dtWall) sits beside the scan machine — wall-time, outside the coefficient vector, no random draws, so the speed limiter never budgets for it and nothing here can perturb the organism. Targets come from states the organism has already slewed:

half  ←  0.62·activity + 0.55·(morph speed) + 0.25·(event in flight),  damped by fatigue
reg   ←  cut · (0.30 + 0.70·min(1, mesh + 0.5·activity))
mids  ←  scan wake + 0.12·activity·half

and every one of them moves through an asymmetric slew: ~2.5 s to bloom, ~9–11 s to relax. Appearance is growth; disappearance is dissolution. A calm or exhausted organism relaxes to the bare invariant, which is why SEED and a fatigued creature still show the plain frame.

Measured over 150 simulated seconds on one instance:

Maximum change in any weight in a single frame: 0.016. A pop is not merely absent; it is structurally unavailable.

The frame briefly becomes the instrument, then returns to the invariant. A wall-time state machine, again outside the coefficient vector, firing on morph events (TRANSIT, SURGE or CRISIS with an event actually in flight, 13–22 s cooldown) or after 24–58 s of quiet.

Mode 0, the laser sweep (78%). A red sheet on a random axis, eased across ±1.15 of the cage over 4.5–8 s, intensity ramped in and out. Inside the sheet: a fine 12×12 mesh at constant screen width, a faint field dimmed as the sheet turns edge-on so it never veils the frame, and a bright rim where the sheet meets the cage. On the body: a cross-section glow where the sheet cuts the surface — a tight exp(−d²·2400) core inside a wide ·300 halo. The laser reading the lattice.

Mode 1, the mesh flash (22%). All three mid-plane meshes at once, 3.2–5 s.

Everything is additive paint, occluded against the body's hit distance and clipped to the frame, so containment and the invariant are untouched. An autonomous run fired three scans in 65 simulated seconds — modes 1/0/1, three different axes, during CRISIS, CRISIS and SURGE.

The surface is built on the LATTICE INDEX architecture: one shared tissue basis — a drifting warped domain, cellular F1/F2/identity, two-octave value noise, ridged noise, axial laminae — read differently by ten genes, over a dark polymer matrix that the pattern opens bright domains in.

The critical architectural choice is that genes shift a palette coordinate rather than contributing colours to be averaged. Two active genes beat against each other and produce bands neither one contains. Averaging colours produces mud — an earlier iteration proved that at length. Beating produces hybrids.

Colour comes from seven cosine palettes — cobalt-cyan, slate-ember, gold-rose-sky, mint-steel, bone-charcoal, oil-violet, sage-cobalt — walking on 92-second epochs with a dwell, so the whole colour world migrates without ever cutting.

The gene weights themselves live outside the coefficient vector, with per-gene lags of 7.5 to 18 seconds of skin time and targets driven by sixteen mutually incommensurate clocks sampled on skin time plus a slow wall trickle. A normalisation of 1.75/max(1.75, Σ) keeps two or three genes dominant instead of all ten averaging into grey. The surface therefore never repeats and never presents as a slideshow of ten textures.

An early iteration of this module painted wire nets onto the surface, and was rightly rejected: "you're still not adding real wrapped wireframe meshes... you've just done the same thing again." The nets are now in the distance field:

glsl

dW = (sqrt(dLat² + gA²) - wr)/1.45;                     // the wire
dN = (sqrt(dLat² + gA² + gB²) - wr*2.35)/1.75;          // the ball joint

The net runs along the intersection curves of the isosurface with the cell-boundary grid — real tubes on real curves — and where two curves cross on the surface, a node sphere 2.35× the wire radius: the node-and-strut read of the plates. They shade as their own material, occlude the body, and catch their own specular.

They fade by erosion, not by radius, because a tube of zero radius is still a line at distance zero and the marcher keeps finding it. That lesson is inherited directly from Colony Morph and ICOSA Morph, where it cost real debugging time in both.

The wrapped polyhedron — twelve icosahedron vertices sphere-traced onto the body CPU-side each frame, drawn as thirty conformal edges — needed one rule the earlier modules did not: a ray that falls through a pore must not drag its vertex to the core. A real net drapes across a hole. Vertices that find nothing hold at the body's outer radius instead, and the whole shell is temporally smoothed at 0.22 so it rides the morphs without jitter.

This is the most transferable idea in the module, and it was earned by a bug.

Some regions of the morphospace are degenerate: a level set that becomes three families of planes rather than a surface; a wall thin enough to shatter into fragments; a wall thin enough to be invisible. The obvious way to keep the organism out of them is a projection — clamp the position onto the safe set.

A projection onto a non-convex set is discontinuous. "Keep |level| above a threshold" is exactly that: as the level drifts through zero the projection flips sign and the level jumps by twice the threshold in a single frame.

Measured, seed 404, frames 11486–11601: the level oscillating +0.070 / −0.070 on alternating frames for the best part of two seconds. A whole-body topology flip thirty times a second. And no timestep reduction can damp it, because the jump does not scale with h — which is why the inherited three-layer speed limiter was retrying four times a frame and clipping, and still could not stop it. Across forty minutes and five seeds, every single frame with a coefficient jump above 4% of its range was this one clause, and no other axis ever moved more than 0.4% in a frame.

The replacement is a smooth penalty plus a gradient projection on the step:

c0 = gateCost(b)
if c0 < 1e-4: return                       // far from every wall, do nothing
g  = ∇gateCost                              // 12 axes, central differences
if g·(b−a) ≤ 0: return                      // this step already descends
b -= g · (g·(b−a))/|g|² · min(1, c0·2.6)   // remove the climbing component

Removing the climbing component rather than the whole step is what lets the path slide along a constraint instead of stalling against it or being thrown across it. Far from every wall the cost is exactly zero and the whole mechanism is inert.

Six gates are live: the plane degeneracy of a nearly pure {111} shell at low phase; the shatter ceiling on wall thickness, driven by the fragile {200} and {220} content and evaluated on the blended vector because a hybrid can be fragile where both parents are robust; the in-phase cosine conjunction; a visibility floor; the soap-bubble gate; and a pore wall/cell ratio.

All twelve landmarks read gate cost exactly 0.0000. That is not decoration — it means the authored states sit in the interior of the safe set, and the gates only ever act on drift.

{100} is cos+cos+cos, {110} at phase zero is a sum of cosine products, and {111} at phase zero is cos·cos·cos — all even about the same lattice points. Lit together, their maxima coincide, and a positive level cuts the field into isolated blobs around those points instead of into a surface.

Measured, seed 404: phases 0.138 and 0.116 off zero with {100} at 39% and {110} at 41% of the amplitude produced six disconnected pieces, the largest holding 39% of the body. Turning the {110} phase alone to a quarter turn restored 99.6% connectivity; a half turn, 100%.

The gate must therefore be a conjunction and not a sum of suspicions: I-WP is {110}(0) + {200} with no {100} and no {111} and is a perfectly good surface; Neovius is {100} + {111}(0) with no {110}. Each of the twelve landmarks zeroes at least one factor of the product.

The first version of this gate was written from theory rather than measurement, and it was wrong. It quietly corrupted four authored landmarks — Perforate at gate cost 0.332, Radiolarian 0.315, Core Shell 0.166, Neovius 0.087 — pushing their levels and thicknesses off the values that made them themselves. Ablation found it: setting the hierarchy coefficient to zero produced a null result, setting the level to zero restored the forms, which fingered the level-based term and exonerated the rest. The speculative gates were deleted and replaced with the measured one.

This is the part worth reading even if none of the mathematics is interesting.

The module rendered flawlessly in every test environment. On the machine it was made for — an Apple M4 Pro — it drew nothing. Black in Brave. Black in Safari. And on the very first open in Brave it took down the browser's shared GPU process, after which every WebGL page in every tab, including long-stable modules from earlier in this series, showed "WebGL2 required" until a full browser restart.

Fragment shader cost. The wrapped-polyhedron shell had been implemented as thirty capsule distance functions inside the map function — the one the raymarcher calls at every step. At 176 steps that is roughly 5,300 ray/segment tests per pixel, before the skin's double cellular pass, the cage, the scans and ambient occlusion, at retina supersampling, on frame one. Real GPUs enforce a watchdog; exceeding it resets the GPU; in Chromium the GPU process is shared across tabs, so one over-budget shader takes WebGL down browser-wide. SwiftShader — the CPU rasteriser behind every test render — has no watchdog, which is why no harness had ever caught it.

The fix was architectural: the shell moved out of the march and became one analytic pass per pixel — thirty closest-approach tests once, occluded against the body's hit distance, with soft node dots at the projected vertices. O(steps × 30) → O(30). Measured at 300 px and 150 steps with the shell forced on: 955 → 465 ms per frame. Startup quality was dropped so the first frame is the cheap one, and the frame-rate governor was made to earn quality back rather than start at maximum and shed after the damage is done.

The GPU-process crashes stopped. The screen stayed black.

A diagnostic build was added: a boot log on canvas, compile and link timing, and a self-bisect that ran the shader through seven progressively simpler stages, sampling nine pixels of each with readPixels and printing a verdict line.

The result came back from both browsers, identical:

REPORT: S0-BLACK S1-BLACK S2-BLACK S3-BLACK S4-BLACK S5-BLACK S6-BLACK

Stage 0 is outC = vec4(0.06, 0.30, 0.16, 1.0); return; — a constant colour, before any geometry, before any uniform is read. It read black while the page ran at 60–120 fps with no JS errors, no context loss, a successful compile and a successful link.

That result is the whole diagnosis in one line: the pipeline is per-program, not per-branch. No runtime uniform branch can heal a program whose backend pipeline is dead, because the branch is inside the thing that is dead. Every stage was always going to report black.

One number in the log stood out: link time 61–80 ms on Metal against 1–5 ms in the emulator.

• Raw shader size. Colony Morph's fragment shader is 33,251 bytes; this one is 31,003 — the larger shader runs fine on the same machine. Size is not the variable.

• Boilerplate. Identical context attributes (antialias:false, alpha:false, depth:false, preserveDrawingBuffer:true), identical attributeless gl_VertexID fullscreen triangle, in two modules that both work.

• ES 3.00 legality. Both shaders pass strict glslangValidator, and both translate cleanly through SPIR-V to Metal Shading Language via spirv-cross.

• The readback itself. A five-line mini-program compiled, drawn and read back in the same task validated the measurement path independently of the main shader.

Not knowing the cause, the next build hedged against all of it: one fragment shader compiled into five preprocessor-stripped tiers (flat paint → clay body and cage → full material → wire nets and shell → nano-skin and scans), a boot watchdog that samples real frames and rebuilds one tier down whenever they read black with the probe proven lit, NaN-sanitised uniform uploads, and a verdict line for every failure mode. Every tier was verified to compile and draw, and a simulated dead pipeline was verified to recover in under a second.

It was the right engineering for an unknown cause. It was not the answer, and it is preserved rather than shipped.

"You need to figure out what bug is causing this when you attempt to add the laser scanning to the module."

That reframing is what solved it — not the tooling. Taking it seriously produced a census across every build that had ever run on that machine, and the census is unambiguous:

Nodal Morph is the only SETHIX module that has ever used fwidth, and it is the only one that has ever drawn black on that hardware.

Metal compiles derivative instructions as quad operations that must execute in uniform control flow. A derivative under divergent flow — inside a loop with data-dependent break/continue, or beneath a per-pixel if (hit) — is precisely the pattern its shader compiler can reject silently: the GL-side link "succeeds", and then every draw with that program writes nothing. SwiftShader tolerates it. Strict validation permits it. SPIR-V→MSL translation performs it without complaint. Nothing in the entire verification stack sees it.

The first narrowing of this was still too specific — the scan block's fwidth sat inside a loop with non-uniform exits, which made it the obvious suspect, and removing it was not enough. A ?noscan=1 build that stripped the scan code entirely still drew black, which falsified the loop-specific theory and moved the fault to the remaining derivative: isoL, the mesh-line painter, which had carried an fwidth beneath the per-pixel hit branch since the module's first build.

No derivative operations anywhere in a SETHIX fragment shader. Not in loops, not under branches, not in helpers.

What fwidth measured has an exact first-order closed form. For a field with world gradient g, on a surface with normal n, viewed along rd, at pixel footprint pxw: a one-pixel screen step s (perpendicular to the ray) lands on the tangent plane as δ = s − rd(n·s)/(n·rd), so the footprint is the maximum of |δ·g| over s —

glsl

float fwOf(vec3 g, vec3 n, vec3 rd, float pxw){
  float nr = dot(n, rd);
  nr = abs(nr) > 0.05 ? nr : (nr >= 0.0 ? 0.05 : -0.05);
  vec3 w = g - n*(dot(rd, g)/nr);
  w -= rd*dot(rd, w);
  return pxw * length(w);
}

The grid families pass their constant axis gradients; the ring family gets the true local ∇F from three forward taps of the field. The scan sheet uses the same idea with its own planar geometry.

An intermediate version used an isotropic 1/cos obliquity and the global Lipschitz bound instead of the true local gradient. Both are over-estimates, both widen the lines, and the mesh visibly washed out — 17–21% of pixels differing from the original on the mesh-heavy landmarks. The exact form brings that to 0.3–4.9%, and side by side the pairs are indistinguishable.

The module now renders on the hardware it was made for.

The failure mode that cost the most was not the bug; it was that a dead pipeline is silent. So every load now ends its first synchronous frame by reading back five spread pixels. If they are all black although compile and link succeeded, the module bisects itself — rebuild without the scan block, then rebuild as flat paint — and prints one verdict naming the dead layer, with the unmasked renderer string, to both the on-canvas panel and the console. The screen always shows something: the organism, the organism without scans, or flat green and a sentence explaining why. Verified end to end against a deliberately sabotaged build.

A black canvas is never again allowed to be the whole message.

The azimuth had always looped. The elevation had not: it swung between about +2° and +36°, so in the entire life of every previous build the underside of the object was never once seen.

The elevation now sweeps pole to pole, ±72°, on the same golden-ratio-detuned rate the module already carried:

azimuth   2π / 0.152                = 41.3 s per revolution
elevation 2π / (0.152 · 1/φ)        = 66.9 s per sweep

The two periods are incommensurate, so the eye rides a precessing loop over the whole view sphere and never repeats a pairing. Verified rather than asserted: binning the sphere into 12 azimuth × 6 elevation cells and tracing ten simulated minutes visits 72 of 72 cells. The sine's natural dwell near its extremes reads as a slow pirouette over each pole — looking straight down through the grid into the lattice — before the path dives back through the equator. Manual dragging is pole-clamped so the basis can never flip.

Framing takes four fill targets simultaneously and the largest wins: bulk 0.74, tip 0.84, cage 0.99, outer 0.99. A form that is mostly thin spicules is framed on its mass, and the threads are allowed to run off the edge — which is how one would photograph it, and the difference between a spiky organism reading as large and reading as a small knot in a lot of black. The cage never runs off.

A single multiplier, camZoom, then scales the final framing radius, after every fit term, so bulk fill, tip relax, cage fit and bound reach all keep working proportionally and only the settled distance changes. It ships at 0.85 — chosen on the artist's own display via a temporary slider, then baked and the slider stripped. The piece fills about 80% of the frame, up from 67%. Verified safe across all twelve landmarks; the tightest case (SEED) still settles well outside the cage.

Stills are nearly useless for work like this. Every bug that mattered in this module was invisible in a frame and obvious in a derivative, a difference, or a count.

Coefficient continuity. The inherited speed limiter bounds the total perceptual change per frame by retrying with a smaller step. So anything that survives it is, by definition, a jump that does not scale with h — a projection or an assignment, not integration. The harness steps the organism at 1/60 for minutes across several seeds and reports the worst single-frame move per coefficient as a fraction of its range. That is how the ±0.070 level oscillation was caught, and it is the standing regression: zero jumps above 0.4% of any axis range, clip 0.004%, on every build in this article.

Connectivity. A hit-mask build plus flood fill over the rendered body, which is what turned the in-phase degeneracy from a suspicion into "six pieces, largest 39%".

Containment. A build whose fragment shader flags any hit point outside the cage in red, so the property is measured in the renderer rather than predicted from the CPU mirror. Predictions had already been wrong once: an early landmark comparison predicted bit-identical output and measured a mean difference of 4.33, which traced to a Lipschitz uniform the prediction had not accounted for.

And measurements that turn out to be measuring the wrong thing. Preparing this article, the shipped march step (stepScale 0.90) was compared against a "reference" rendered with a much smaller step, and came back differing on 7.3% of pixels at the median and 24.1% at the worst — apparently the same overshoot defect ICOSA Morph documented.

It was not. A smaller step against a fixed step budget travels less far, and the shader's march loop is hard-capped at 256 iterations: the fine "reference" was simply failing to reach the surface. Tested properly — the shipped configuration against the deepest render the shader can perform —

on GYROID, RADIOLARIAN, HIERARCHIC and CORE SHELL. The shipped march is converged: there is neither overshoot nor step starvation, and lowering the step scale would only shorten the reach. The first table was an artefact of its own reference and is recorded here because publishing it would have been worse than useless.

The step-scale comment describes the bound it replaced. The source justifies stepScale: 0.90 by saying the Lipschitz bound "measures 1.7–2.1× looser than the realised gradient". That ratio belongs to the naive Σ|a||k| bound. The shipped bound sits 1.04–1.20× above realised — much tighter — so 0.90 is a genuine 10% margin, not the comfortable one the comment implies. The convergence measurement above says the margin is sufficient in practice on all twelve landmarks; the comment's arithmetic is still wrong and should be corrected rather than trusted.

boxProbe is now dead work. The 192-direction sphere-traced bounding-box probe, with its compass refinement, still runs every frame — and since the cage became invariant, nothing reads its output. ORG.rBox is written by the probe, smoothed by the probe, snapshotted by the limiter, and consumed by nobody. It is the dominant cost in a 1.47 ms CPU simulation step. Removing it (keeping wrapShell, which genuinely feeds the wrapped polyhedron) is free performance. It is retained in this build only because it was verified working and the framing code may want it again if the envelope mode is ever promoted.

CFG.cageFit is dead, referenced only from a comment, for the same reason.

The step clamp has a dead range. setSteps clamps to 512, but the fragment shader's march loop is for(int i = 0; i < 256; i++). Any value above 256 is silently ignored. Harmless — the live ceiling is 176 — but it means harness numbers above 256 are not what they say.

The mechanism behind the derivative bug is inferred, not documented. What is measured is the correlation (four derivatives, black; zero derivatives, renders) and the fix (zero derivatives, renders on the target hardware). The explanation — Metal's quad operations requiring uniform control flow, and the compiler rejecting silently after a successful link — is the standard reading of that behaviour, not a vendor statement. The law is stated as a hard rule anyway, because the cost of following it is a closed-form function and the cost of breaking it is an invisible module.

This morphospace is far less anisotropic than Colony Morph's. Its perceptual sensitivity table spans 12.9× from quietest to loudest (rou 11 to frq 142), against Colony Morph's 116×. The orthonormal basis is most of the reason: no axis secretly moves another, and the loudest axes are the two that rescale everything (frequency and cell count). The three-layer limiter is inherited whole regardless, and does less work here.

The base retains the shell inside the march, and full-quality startup, rather than the analytic-shell and cheap-first-frame mitigations. This was the artist's deliberate choice of base build, made before the real cause was known, and it has since been confirmed rendering on the target hardware. The mitigations are documented and ready if a slower machine ever needs them.

Every one of these was invisible in a still frame. Several are the same mistake wearing different clothes: a gate placed where the thing being gated is not yet zero, and a model of a quantity that is not the quantity that reaches the screen.

The event path assigned positions instead of integrating them. The transition branch wrote the Bézier point directly into the coefficient vector. Combined with the gate offsets, that made every correction self-perpetuating: the gate pushed the state off the curve, the next frame's assignment snapped it back, and the pair oscillated until they vanished together. Rewritten to integrate — x += B(u₁) − B(u₀) — with the previous parameter recomputed rather than remembered, so a limiter retry reproduces it exactly, and the wobble carried as increments so it never accumulates into a random walk.

The hierarchy carve compared a distance against a constant. A unit mismatch that meant the second scale never fired at any coefficient value.

Two envelope terms cancelled each other into a sphere. High box with positive cub produced a plain ball — the L8 rounded cube and the cubic harmonic annihilating at cub ≈ 0.21. The landmark families were separated in the (box, cub) plane once it was found.

The bounding-box probe stepped over the walls it was measuring. A fixed 12-step radial scan advances 0.069 per step; the sheet's world thickness at NEOVIUS is about 0.017. The scan walked straight past the outermost wall and reported the next one inward, so the box came back up to 13% short — and no number of extra directions could have fixed a radial miss. Sphere-tracing each ray fixed it, and is cheaper: a conservative distance cannot skip a surface.

The wrapped shell's vertices fell through the pores, collapsing the net toward the core. Fixed by the drape rule.

Three inverted smoothstep(hi, lo, x) calls. Undefined behaviour in GLSL ES 3.00, tolerated silently by SwiftShader, which is why the dendritic gene had been mute. Rewritten as 1.0 − smoothstep(lo, hi, x).

Gene tiles that were identical, then washed out, then muddy. Three iterations: pattern scales an order of magnitude too coarse; a tint layered over the existing blue material; and a compositor that averaged gene colours. The architecture that worked — beat the palette coordinate, never average the colours — came last.

The diagnostic build crashed on its own diagnostics with a temporal-dead-zone error, because the bisect driver was referenced by the draw loop before it was declared. Worth recording because a diagnostic that cannot boot reports nothing, and for one build the black screen being investigated was partly its own instrumentation.

And the derivative. Four instructions, one of them present since the module's first line, invisible to every validator, every translator and every test renderer, and fatal on the only hardware that mattered.

?seed=<n> reproducible instance · ?ss=<n> initial supersampling · ?zoom=<n> framing multiplier, 0.40–1.60 · ?noscan=1 compile with the scan blocks stripped · drag to orbit · space to pause.

window.SETHIX — state(), probe(), nodal(x,y,z), field(x,y,z), lip(), occ(), clip(), vel(), iterms(), log(), pixels(); play(), halt(), sim(dt), step(dt), seek(t), redraw(), force(); pin(name), set(k,v), settleCage(), gateCost(v); pinCam(t), camR(), zoom(), setZoom(z); setSS(s), setSteps(s); scanNow(mode, axis, pos), scanOff(), scanState(); cageState(), cageForce(half, reg, mids); genes(a), geneW(), skinSeek(sec).

cfg is live for anything read per frame.

Per pixel that hits: up to 176 march steps, each a full field evaluation — six transcendentals and about twenty-five multiply-adds for the nodal field, the rounded-cube cut, optionally a second nodal field for the pores, the surface net with its ball joints, and the spicules. Then four taps for the normal, five for ambient occlusion, the material once at the hit, and one analytic pass each for the cage, the graduations, the wrapped shell and any active scan.

The material and every frame-decoration pass are evaluated once per pixel, never inside the march loop — which is the single most important performance property in the file, and the one whose violation caused the GPU-process crash.

CPU: one simulation step is 1.47 ms, dominated by the now-consumerless bounding-box probe.

The adaptive controller trades march steps (136–176) against supersampling (0.60–1.60) to hold ~58 fps. Frame rate could not be measured meaningfully during construction — verification ran under SwiftShader at seconds per frame — so the controller, not a measured number, is the guarantee.

Framing — fov 34° · spin 0.152 (41.3 s/orbit) · camElev 0 ± 1.26 rad (±72°, 66.9 s/sweep, ratio 1 : 1/φ) · camZoom 0.85 · camMin 0.95 · camTau 2.10 · camRateOut 0.115 · camRateIn 0.072 · camBoost 1.70 · camDead 0.030 · fillBulk 0.74 · fillTip 0.84 · fillCage 0.99 · fillOuter 0.99 · frameLerp 0.16 · tipRelax 0.42 · tipFloor 0.87

Stage — cage0 1.25 · 3×3×3 · line weight 1.55 px · colour (0.980, 0.105, 0.090) · graduation bloom ~2.5 s / relax ~9–11 s · scan wake decay 7.5 s

March — maxSteps 176 · minSteps 136 · stepScale 0.90 · surf 0.00055 · maxDisplay 1280 · ssMin 0.60 · ssMax 1.60 · fpsTarget 58

Governor — probeMs 180 · probeN 512 · strainRef 0.290 · reachRef 2.40 · reachW 0.220 · psiHi 2.40

Limiter — vCap 21.0 · vTarget 10.0 · vDrift 7.0 · wobA 1.5 · maxRetry 6 · brakeK 0.92 · brakeP 2.90 · brakeFloor 0.22 · iZero 0.625 · iGain 2.391 · winShort 2.0 / cap 16.0 · winLong 12.0 / cap 13.0

Skin — skinBase 0.055 · skinGain 0.95 · skinTau 1.25 · phiW 0.66 · actSlew 0.055 · travelTau 7.0 · travelLo 15.0 · travelHi 62.0 · matExc 0.105 · matTau 2.20 · mCapMax 15.5 · palette epoch 92 s · gene lags 7.5–18 s

Dead — cageFit 1.080 (comment-only) · setSteps range above 256 (shader loop cap)

A finite chunk of triply periodic minimal-surface lattice lives inside an invariant red crystallographic stage.

The morphospace is a five-shell orthonormal cubic Fourier basis in which Schwarz P, the gyroid, Schwarz D, Schoen I-WP, Neovius and F-RD are each a single point, verified to 1e-15, with chirality as one continuous phase coordinate — the gyroid and its achiral partner occupy the same twelve wave vectors and differ only in phase. The body is not a field inside an envelope: it is a rounded-cube cut of half-side cells·π/frq, so the cut faces land on lattice planes by construction, at every frequency, continuously. That single expression is what keeps every drifted hybrid reading as a cut crystal instead of a textured ball.

The frame is a constant. One red 3×3×3 grid, one extent, one weight, one colour, and a 1-Lipschitz stage cut in the field itself that makes containment true by construction — measured at zero offending states out of eighty, with the body reaching to 0.996 of the wall. What varies is the structure that grows inside it: interstitial half-bars that crystallise line by line, face grids drifting on incommensurate clocks, and a registration grid whose lines sit at the body's own cell pitch and glide as the lattice tunes itself — all slewed from the organism's metabolic activity and morph speed, blooming over 2.5 seconds and dissolving over nine, with a maximum weight change of 0.016 per frame. Laser sheets sweep the cage on morph events and leave their planes crystallised in their wake.

The surface is a ten-gene nano-skin on a shared tissue basis, where genes shift a palette coordinate rather than averaging colours, so two active genes beat into hybrids neither contains. The wire nets are real geometry in the distance field, with ball joints where curves cross, fading by erosion because a tube of zero radius is still a line at distance zero. Topology gates deflect the coefficient path along their constraints rather than projecting it across them — the projection version was a whole-body topology flip thirty times a second, and it was the only discontinuity in the module.

And the module drew black on Apple hardware for a fortnight, through a GPU-process crash, an architectural cost fix, a seven-stage self-bisect, and a five-tier self-healing renderer — because of four fwidth instructions. Every other SETHIX module has zero. The replacement is the exact first-order footprint in closed form. Every load now ends its first frame by proving to itself that it drew something, and says so in one line if it did not.

Pure WebGL2, one file, no dependencies, no assets, no geometry beyond a single fullscreen triangle. The camera covers the entire view sphere and never repeats.

All code is open source.

Contract: 0x71eb648bdd6ebb161dcda890dfadd1d28972ea42 — Substrate Transmutation [SETHIX] on OpenSea. Media on Arweave.