The medium

The medium is what fills the space between subjects in the field: the summed interference of a wave emitted by every subject in the graph. It is not a backdrop the subjects are placed on and not a pattern laid over them, and no line, tube or segment is drawn anywhere in the picture. A bright place is a place where two or more sources agree, which makes a fringe a subject by construction rather than by arrangement.

Sources and their sum

Every node is a source. Its amplitude rises with its mass and falls exponentially with distance from it, and its phase is a number carried per node. The radius used for both is softened by a constant added under the square root, the same softening the coordinate warp uses, so there is no singularity at the middle of a well for the phase to be wrong about.

All sources share one frequency, and that is what removes the loop. With one shared frequency the time separates out of the sum exactly:

sum A_i sin(theta_i - omega t) = S cos(omega t) - C sin(omega t)
S = sum A_i sin(theta_i)      C = sum A_i cos(theta_i)

The bake therefore writes two static scalar fields, S and C, and the march rebuilds the whole animated medium from them with one cosine and one sine taken once per frame. S and C are stored rather than amplitude and phase because they are what a trilinear filter is allowed to average: the sum is linear in them, while a phase read halfway between the top and the bottom of a turn is the one value the two voxels agree it is not.

A source both emits the medium and swallows it. The same node loop that adds a wave also accumulates an occlusion term, and the march spends that term as a negative exponential on everything the medium contributes at that point. The result is a void with a lit wall: the field is darkest exactly where mass has collected, and what lights the picture is a source’s own emission just outside its own well, plus what runs between the wells. A separate wall term peaks where the well is half swallowed, which is the same shell of space the emission peaks in, so the wall is a dial over a silhouette the medium already produces rather than the thing producing it.

Each source also drags the sampling lattice toward itself, by its mass over the square of the distance. The medium is read at that bent coordinate, which compresses and swirls it into a well wherever information has collected. The displacement one source applies is a fraction of a wavelength, and it has to stay one: a warp of order a wavelength would carry a sample onto a neighbouring fringe, and the bright place would stop corresponding to the source that made it. Past that bound the field is no longer readable as a map.

What an edge does

An edge renders nothing. It sets a phase relationship, and two sources held in phase interfere constructively along the ridge between them.

The phases are settled before the bake runs. Each source starts at a phase hashed by integer arithmetic out of the position the corpus put it at, so two subjects that share nothing are incoherent and the space between them stays flat. One round then turns each source toward the weighted vector sum of the neighbours it is joined to, its own phase counting as one term. The round count is fixed at one: any positive coupling run to convergence on a connected graph is global synchrony, and a corpus in one phase is a corpus where every pair interferes as strongly as every other. A lock is a pull rather than a decree, so a subject with one heavy reading on it ends up nearly in phase with that reading’s other end, while a subject whose mentions disagree is pulled by their vector sum and stays near where it started.

How hard the pull is scales with the edge’s weight, and the weights are fixed by kind:

Two nodes joined for more than one reason keep the strongest of them.

The ridge itself needs no primitive. The joint loudness of two sources falls off in the prolate spheroid coordinate s = (r_a + r_b) - |a - b|, which is zero exactly on the segment joining them, positive off it, and a function of nothing but the two positions. The filament is the degenerate member of the family r_a + r_b = constant. Its half width grows as the square root of the pair separation times the source falloff, so it reads as a thread rather than a lozenge only while that falloff is well under the separation. A pair with no edge between them stays incoherent and the space between them stays flat. The visible difference between a heavy reading and a passing mention is fringe coherence, not tube radius.

The bake’s edge loop still runs, and what it produces is measurement rather than light: how much coupling crosses this point, which the heatmap colours; the axis the coupling runs down, which the three colour channels are separated along; and a groove leaned into the sampling lattice along the filament.

The bandwidth ladder

Nodes are the local maxima of a density estimate over the space, rho(x) = sum_i mass_i * exp(-|x - pos_i|^2 / (2 * sigma^2)). A wider kernel merges neighbouring maxima. The sequence of merges is a tree, and that tree is the abstraction hierarchy, so level of detail and level of abstraction are one control rather than two data structures.

The ladder is four rungs, each half the resolution of the one below:

A rung’s kernel width is one and a half voxels of its own grid, tied to the sampling rather than chosen, because a bandwidth narrower than the grid is a field the grid cannot see. The density kernels are squared distances and widen with the bandwidth squared; the medium’s wavelength and falloff are plain lengths and widen with it once.

Maxima are found by climbing the density on the rung’s own grid from each node’s own voxel, uphill over the twenty-six neighbours, at most sixty-four steps. Two nodes that climb to the same voxel are one component. A union-find carries the merges forward and is never reset between rungs, which is what makes the tree a tree: a merge at one bandwidth is never undone at a wider one. A rung that finds the same grouping again creates no new entry.

A component’s mass is combined and not summed. Mass is a nought-to-one reading everywhere else in the field and the shader reads it as one: a well’s kernel width falls with mass, and a mass driven past that range inverts the well and turns a merged component into a light source instead of a hole. Combining leaves a single member exactly as it was, which is what keeps the finest rung identical to the graph.

A rung that leaves fewer than four components is not a coarser reading of the field but a different picture, so the ladder reports a ceiling of the widest rung that still leaves at least four, and the cost manager takes that rather than the length of the ladder. In the label layer, a subject whose component another label already stands for fades and stops taking the pointer, while the label standing for it moves to where the merged well actually is. It never leaves the reading order, because a page represented by another page is still a page the site promises is reachable.

The baked volume

The march samples a volume. It contains one loop, over depth steps, and no loop over nodes or edges at all: the arithmetic above runs once, into textures, in a second program that is not the picture.

Per rung, four RGBA8 three-dimensional textures carry sixteen channels:

The two indices address a lookup texture of 256 texels by two rows, which the runtime rewrites each frame with every component’s family colour, how lit it is, its mass, and each channel’s lighting. That live lighting is the one thing that cannot be baked. It also fixes the ceiling: a rung with more than 256 components or channels is refused and the ladder starts a rung up.

One march step takes five fetches of the volume, three of the lookup, and three more of the medium at the three points the colour channels are separated to. The cost stops depending on how much corpus is in view.

The whole set is 280,800 voxels and 4.49 MB of GPU memory, and it is generated once per tab rather than shipped. Shipping it would be roughly a megabyte compressed on the wire, paid by every visitor including one who lands on an article and barely sees the field, and regenerated on every commit that adds a subject. What the ladder budgets is GPU memory and fill, not download. What does ship is the merge tree, which the static build computes once and writes into the page.

The bake is attempted with rung 0 as the finest, then with rung 1, which quarters both the memory and the fill. A driver that will not give four colour attachments, will not allocate a three-dimensional texture or will not complete the framebuffer gets the next attempt, and when the attempts run out the field takes its own flag down and the page becomes the ordinary document it falls back to, with the label layer as a link list. The old looping shader is deliberately not a rung below that.

What the cost manager gives up

The march is sized by what the last second of frames actually cost, smoothed. Three levers are spent, in this order:

Resolution goes first because a softer haze is still the same field. The bandwidth goes last because a rung is the same point cloud under a wider kernel rather than a smaller point cloud, which is what makes it a defensible thing to give up where dropping nodes was not.

A rung is not free. The merged wells swallow more of the field while their combined mass pulls less light into it, so a coarser rung is a dimmer field as well as a coarser one, and a test holds that loss to a floor so it cannot quietly get worse. A level change also moves the wells themselves, so it is held rather than slid: the same rung has to be asked for twenty frames running before it is taken, where the resolution can change mid-motion and nobody sees it.

Two limits sit outside the loop. The canvas is never rendered above 1.25 device pixels per CSS pixel, however sharp the screen is, because the volume is a haze with no fine detail to resolve. A reader who has asked for reduced motion gets a clock that does not advance and a frame that is skipped entirely while the camera and the lighting are unchanged.

What the field reads today

The point cloud the medium is emitted from is the site’s own graph: the pages that are not corpus subjects, the corpus subjects themselves, and one node per exegete, joined by the four edge kinds above. A node’s mass is how much has collected on it, and its position is measured from its content rather than from its edges, which is the seam described under measured position.

The design this facet documents has the field be a density readout over the elite archive of bred artifacts, indexed by behaviour space. That is not what it reads now. No outcome records are on disk, no encoder is trained, and nothing bred is a source in the medium today. What is live is the readout: the ladder, the bake, the march and the cost manager all run against the corpus, and they take a point cloud with masses and weighted edges without asking where it came from. An archive that starts producing records adds sources to the same volume rather than replacing it.

The corpus is also why the ladder currently runs short. On a cloud this size the widest rungs merge past four components, so the ceiling sits below the length of the ladder and the coarsest rungs are never bound. They return on their own as the cloud grows into them.