PulseCore

Chapter 2 · Section 5

The Pulsecore as a Bubble of Data

The BPT law

BPT Part 3.6, "The Pulsecore as a Bubble of Data," describes the Pulsecore while it fills. "A universe begins across three parts. On the parent's side is the Nullcore ... Between them is the Bifold, the line between the dimensions ... On the child's side is the Pulsecore, the child's data held within the Bifold." "The Pulsecore is a bubble, and the Bifold is its skin. It is Planck-sized in the units of the universe it begins, and it holds data inside as well as on its surface." Before the physical layer the data has no mass, "so nothing holds it back. It is not a gas ... but radiation: it moves freely at the local light speed 𝒞→ and fills the Pulsecore as light fills a hot cavity. The data within crosses the bubble, strikes the Bifold, is written there and sent back in, and turns with the spin of the Bifold that holds it." Three named laws follow, which pinpoint.js:1–33 restates:

  • Pulsecore Data Radiance: P_∂ = u/3, u = n·k_B·T, v = 𝒞→. "Massless data within the Pulsecore is radiation, not a gas: every datum moves at the local light speed, and its pressure is a third of its energy density." "A datum within the Pulsecore is always at 𝒞→, and only its direction changes, at each strike of the skin."
  • The Bifold Record Law: Φ_∂ = n·𝒞→/4, the strikes on the skin per unit area per unit time. "The Bifold is the record of the data within: every datum that strikes it is written where it strikes, and the skin sends data back in." "What we see on the Pulsecore's surface is the record of what has struck it."
  • Bifold Drag: v_∂ = 𝒞→·a_f / (1 + √(1 − a_f²)), with n(ρ) = n₀·γ(ρ)³. "The Bifold turns with the universe's spin, its equator at the speed of a spinning horizon's equator, and drags the data it touches, so the data within swirls with the spin and crowds toward the equator."

The established physics

  • The Bifold's speed is the equatorial speed of a Kerr horizon. A Kerr hole of mass M and spin a_f has its horizon at r₊ = M(1 + √(1 − a_f²)) and angular velocity Ω_H = a_f/(2r₊) (G = c = 1). Its equatorial circumference is 4πM, a circumferential radius of 2M, so the equator moves at Ω_H·2M = a_f/(1 + √(1 − a_f²)), which is 1 at a_f = 1 (Kerr 1963; Bardeen, Press & Teukolsky 1972; Misner, Thorne & Wheeler 1973).
  • Frame dragging inside a rotating shell: Thirring 1918, and Brill & Cohen 1966 for a shell at its own horizon dragging the interior fully, as the code comment cites.
  • A datum leaving a wall leaves by Lambert's cosine law (cos θ = √u for uniform u), the angular law of emission from a surface. Reflection off the inside of a sphere keeps the angle of incidence, so a track keeps the same chord, 2·cos θ radii, at every bounce.

The game's math

The class PinpointGas pinpoint.js:46 holds the data within as points in the unit ball, with positions, directions, colors and bits.

  • Reach: reach = π pinpoint.js:49, light's path in one flip in units of the bubble's radius. The derivation in pinpoint.js:8–12: a cell is f^L/4 ℨ, so the equator, 4·2^L cells, is 2^L·f^L ℨ, one local Planck length. A flip is half a Planck time, so light covers half the equator a flip: π radii.
  • Count: N = dataWithin(r) with r the Rhythms since the first frame (8.5; 8.4 passed the Tempos processed). want = min(max, N) points (pinpoint.js:120). stepPinpoint() app.js:507 makes the gas with max: 8000, against the constructor's default of 1,200.
  • Birth (pinpoint.js:126–139): the first min(want, 16) points leave the skin at random pulsing cells, taking each cell's color and bit, in a Lambert direction about the inward normal plus the skin's own motion (launch() pinpoint.js:72), renormalized to speed 𝒞→. Every later point is a copy of a random existing point at its place, with its color and bit and a new isotropic direction (the author's ruling of 2026-10-25, "the original zinf points should be multiplying"). The loop tries at most 4·max times a flip; after 2·max tries it accepts a non-pulsing cell.
  • Share: share = N / count (pinpoint.js:140). When N exceeds the points, each point stands for share bits.
  • Flight (pinpoint.js:143–169): each point flies reach along its direction. At the wall it strikes the cell under it (cellAt() pinpoint.js:59), writes there (write()), reflects as a mirror does (u → u − 2(u·n̂)n̂), and goes on, for at most 8 bounces a flip. After the flight, position and direction turn about the spin axis by om = v_∂·π radians, the dragged frame.
  • Writing (write() pinpoint.js:97): a strike trades with n = max(1, round(share)) skin cells in a disc of radius √(share/π) cells about the strike. The first cell gets the datum's bit, and the datum takes that cell's old bit on to the next. Each written cell is set to pulser. The lit bits are conserved: the chain only passes bits along. The pulser count is not: a null cell that is struck becomes a pulser.
  • The skin's turn: skinSpeed(a_f) = a/(1 + √(1 − a²)) with a = min(0.999, |a_f|) pinpoint.js:44. stepPinpoint() adds π·skinSpeed(a_f) radians a flip to the skin's angle (app.js:510).
  • Paths: each point's segments in the flip are kept for drawing, at most 6 a point (pinpoint.js:53, 151). The path's points turn by half the flip's angle at the start and the whole at the end (pinpoint.js:171–174).

Desktop at level 6, near the Data Nova: N = 65,536, so 8,000 points with a share of 8.19 bits; each strike writes 8 cells. With a_f = 0.998 the skin's equator moves at 0.998/(1 + 0.0632) = 0.939 𝒞→, and the skin turns 2.95 radians a flip. On a phone at level 4, N never exceeds 4,096, so there every point is one bit.

How often a datum strikes: a point launched from the wall has chord 2·cos θ with cos θ = √u, so it strikes about π/(2·cos θ) times a flip. Averaged over the Lambert law that is π·E[1/(2√u)] = π strikes a flip if every bounce is followed.

cellAt() maps the sphere to the field with rows proportional to the polar angle θ, not to area.

The milestones (pinpointMilestones() app.js:527) say the core's progress at 25 % and 45 % of χ∂ before the Null Nova and at 75 % and 90 % after it. The scene's null density is N/(χ∂ − N) before the Null Nova and the space made, N/χ_∂, after it (app.js:517). The milestones are recorded in pinMarks app.js:526.

After the Data Nova the gas would go on inside the hole (stepInnerGas() app.js:1090, stepInner() app.js:1135), but both wait on pinSkin, which is never set to anything but null (app.js:1088, 3160, 5261). Since the ruling of 2026-10-26 the Pulsecore empties at the Data Nova, so both functions are inactive.

The method, in plain steps:

each flip inside the Pulsecore:
    N ← (2r)² bits;  draw up to 8,000 points, each standing for N / points bits
    the first points leave the skin at pulsing cells; every later one is a copy of a point already there
    each point flies π radii (light's reach in a flip), and at the wall:
        it strikes the cell under it, swaps its bit with the cells there, and reflects like a mirror
        (at most 8 bounces a flip)
    the skin turns by π · v_∂ radians, v_∂ = a / (1 + √(1 − a²)), dragging the points with it

The code:

// public/game-v8.4/pinpoint.js:44 skinSpeed()
export function skinSpeed(a_f) { const a = Math.max(0, Math.min(0.999, Math.abs(a_f || 0))); return a / (1 + Math.sqrt(1 - a * a)); }

// public/game-v8.4/pinpoint.js:97 write()
write(i, r, c, share, g) {
    const { rows, cols } = this, rad = Math.sqrt(Math.max(1, share) / Math.PI);
    const n = Math.max(1, Math.round(share));
    let bit = this.bit[i], hex = this.hex[i];
    for (let k = 0; k < n; k++) {
        const a = 2 * Math.PI * this.rand(), d = k === 0 ? 0 : rad * Math.sqrt(this.rand());
        const rr = Math.max(0, Math.min(rows - 1, Math.round(r + d * Math.sin(a)))), cc = (((Math.round(c + d * Math.cos(a))) % cols) + cols) % cols;
        const ob = g.lit[rr][cc], oh = g.color[rr][cc];
        g.lit[rr][cc] = bit; g.pulser[rr][cc] = 1; if (hex) g.color[rr][cc] = hex;
        bit = ob ? 1 : 0; if (oh) hex = oh;
    }
    this.bit[i] = bit; if (hex) this.setColour(i, hex);
    return n;
}

// public/game-v8.4/pinpoint.js:115 step() (8.5 passes r, the data's Rhythms: step(r, …), this.N = dataWithin(r))
    step(n, a_f, skinAngle, g) {
        const { rows, cols, max, c } = this;
        this.N = dataWithin(n);
        const v = skinSpeed(a_f), om = v * this.reach;   // the skin's turn this flip, radians, and the dragged frame's
        // data is born at the skin, where the cells pulse (the skin computes), and enters
        const want = Math.min(max, this.N);
        let tries = 0;
        /* ⚠️ THE DATA MULTIPLIES FROM THE PAINTED ZINF POINTS (2026-10-25, the author: "the zinf points in the pulsecore are
           fundamental but everything should build from there ... the original zinf points should be multiplying"): the
           first points leave the skin where it pulses (what was painted); after them every new point is born of one already
           within, at its place, with its colour and its bit, flying off its own way, as (n + 1)² grows */
        while (this.count < want && tries++ < 4 * max) {
            if (this.count > 0 && this.count >= Math.min(want, 16)) {
                const j = Math.floor(this.rand() * this.count), i = this.count++, P = this.pos, V = this.vel;
                P[i * 3] = P[j * 3]; P[i * 3 + 1] = P[j * 3 + 1]; P[i * 3 + 2] = P[j * 3 + 2];
                let a = this.rand() * 2 - 1, b = this.rand() * 2 * Math.PI, q = Math.sqrt(1 - a * a);
                V[i * 3] = q * Math.cos(b); V[i * 3 + 1] = q * Math.sin(b); V[i * 3 + 2] = a;
                this.col[i * 3] = this.col[j * 3]; this.col[i * 3 + 1] = this.col[j * 3 + 1]; this.col[i * 3 + 2] = this.col[j * 3 + 2]; this.bit[i] = this.bit[j];
                continue;
            }
            const r = Math.floor(this.rand() * rows), cc = Math.floor(this.rand() * cols);
            if (!g.pulser[r][cc] && tries < 2 * max) continue;
            const i = this.count++, [x, y, z] = this.pointOf(r, cc, skinAngle);
            this.setColour(i, g.color[r][cc]); this.bit[i] = g.lit[r][cc] ? 1 : 0; this.launch(i, x, y, z, v);
        }
        this.share = this.N / Math.max(1, this.count);
        let strikes = 0, written = 0, sg = 0;
        const p = this.pos, w = this.vel, SEG = this.seg, SC = this.segCol;
        for (let i = 0; i < this.count; i++) {
            let x = p[i * 3], y = p[i * 3 + 1], z = p[i * 3 + 2], ux = w[i * 3], uy = w[i * 3 + 1], uz = w[i * 3 + 2];
            let left = this.reach, bounces = 0;
            while (left > 1e-9) {
                // the distance to the wall along the track: |p + t·u| = 1
                const b = x * ux + y * uy + z * uz, cc = x * x + y * y + z * z - 1, t = -b + Math.sqrt(Math.max(0, b * b - cc));
                const go = Math.min(left, Math.max(0, t));
                const nx = x + ux * go, ny = y + uy * go, nz = z + uz * go;
                if (sg < this.count * this.MAXSEG) {
                    const o = sg * 6; SEG[o] = x; SEG[o + 1] = y; SEG[o + 2] = z; SEG[o + 3] = nx; SEG[o + 4] = ny; SEG[o + 5] = nz;
                    for (let k = 0; k < 6; k++) SC[o + k] = this.col[i * 3 + (k % 3)];
                    sg++;
…

In the game

The bubble is the 3D view's first picture. Before Start the Pulsecore is a sphere at the center of the scene wearing the painted field as its skin (scene3d.js:85), turning slowly; the genesis sets its spin. The two spin sliders, 0 to 0.998 and starting at 0.998 (index.php:161–166), and the collision channel set a_f, which the readout's Spin line shows as "a_f · C" (app.js:2140). With "Show spin and axis" ticked, the spin axis, an angular-momentum arrow and a ring round the core are drawn while the Pulsecore fills (setSpin() scene3d.js:236).

From the first flip after Start, the data within appears inside the sphere as colored points, each in the color of the cell it left, with its flight in the last flip drawn as short colored lines (setGasPoints() and setGasPaths() scene3d.js:405–422). The points grow larger and brighter as the core fills (setCoreDensity() scene3d.js:442). The skin turns at the Bifold's speed, about three radians a flip at af = 0.998; drawn sharp it would seem to jump backward between frames, so the scene smears it along its turn by the angle it swept (blurSkin() scene3d.js:254). A dark violet haze inside the sphere thickens with the null's density ρ∅ = N/(χ_∂ − N) and is gone at the Null Nova (setNullDensity() scene3d.js:1193). On the skin, and in the 2D view, the player sees the strikes as cells changing state and color where the data lands; the field is the skin's map and does not roll.

The page's Universe & Genesis note says "The Pulsecore is a bubble of data inside the Bifold, the line between the dimensions ... The Bifold turns as a Kerr horizon does" (index.php:192).

The four milestone notices and the first-Tempo notice are written but not shown. Their texts include "The data within moves at light speed and bounces off the Bifold about twice a flip; the Bifold turns at 0.94 of light speed with the spin, dragging the data with it" and "The null is nearly packed one to a place · the Null Nova comes when data and null fill the Pulsecore, at Tempo 181" (8.4 app.js:532–539; 8.5 says "at Rhythm 91" at level 6). showToast() returns at once while QUIET is true (app.js:231), the ruling of 2026-10-28 that cleared the notices "to allow the game to process."

The scale model

The points are a scale model of the data within: one point is share = N/count bits, at most 8,000 points (desktop). The writes are exact in bits: a strike of share s trades with round(s) cells. N itself is the model level's (2r)². At the true level 28, N reaches 1.15×10¹⁸ bits; the 65,536-cell drawn skin stands for it.

Where the game and the theory differ

  • The 8-bounce cut shortens the strike rate. It cuts every track with cos θ < π/16 ≈ 0.196, which is 3.9 % of wall-launched points, and lowers the average from π to about 2.8 strikes a flip. The comments give two other figures, "about one and a half times a flip" (pinpoint.js:12, which counts diameters crossed, π/2) and "about twice a flip" (the milestone text at app.js:532). Neither is the strike rate.
  • The Bifold Record Law's flux, n·𝒞→/4, is the same on every unit of the skin's area. cellAt() gives each row an equal share of polar angle, so a polar row's cells cover less of the sphere, by sin θ, than the equator's. Strikes that are even over the sphere fall more often per cell near the equator than near the poles. The torus uses an equal-area map (Part 2.9); the Pulsecore's sphere does not.
  • Bifold Drag also states n(ρ) = n₀·γ(ρ)³, the data crowding toward the equator. The game turns the whole gas rigidly with the skin and weights no density by γ. The radiation pressure P_∂ = u/3 and the skin's temperature are not computed.
  • There is a half-Tempo mismatch between the gas and the nova count. stepPinpoint() uses n = floor(pulseCounter/2) (app.js:508), while the nova test uses floor((pulseCounter − 1)/2) (app.js:4605). On even counters the gas is one Tempo ahead of the count that fires the nova.

Fixed numbers

Number Where What it is Kind
π (reach) pinpoint.js:49 light's path a flip, in bubble radii BPT (Part 3.6, Pulsecore Data Radiance, with Part 1.9's cell size)
8000 app.js:507 most points drawn for the data within CAP
1200 pinpoint.js:47 the constructor's default point limit (overridden) CAP (inactive default)
16 pinpoint.js:127 points born from the skin before they multiply CAP
4·max, 2·max pinpoint.js:126, 136 birth tries a flip; tries before a non-pulsing cell is accepted METHOD (rejection-sampling guard)
√u (Lambert) pinpoint.js:79 the wall's emission direction PHYSICS (Lambert's cosine law)
0.9 pinpoint.js:75 chooses the helper axis for the frame across the normal METHOD (numerical)
0.999, 0.9999 pinpoint.js:88, 163 launch and reflection just inside the wall METHOD (numerical)
1e-9 pinpoint.js:146 the flight's end tolerance METHOD (numerical)
8 bounces pinpoint.js:157 most strikes a point makes in a flip CAP
6 (MAXSEG) pinpoint.js:53 path segments kept a point DISPLAY (drawing only; a strike past the sixth still writes)
0.5 pinpoint.js:172 the path start's share of the flip's turn DISPLAY
π in √(share/π); 1 in max(1, …) pinpoint.js:98–99 the strike's disc, one cell at least METHOD (disc of area = share)
0.999 (a ≤ 0.999) pinpoint.js:44 spin held just under the Kerr bound a_f < 1 METHOD (guard; physics allows any a_f < 1)
1 (1 + √(1 − a²)) pinpoint.js:44 Kerr equator speed PHYSICS (Kerr horizon; BPT Part 3.6, Bifold Drag)
1, 0.6, 0.9 pinpoint.js:92 a point's color when it has none DISPLAY
0.25, 0.45, 0.75, 0.9 app.js:535–539 the milestones' shares of χ_∂ DISPLAY (notices)

The data drawn flying (v8.6, 14 November 2026)

The author, 14 November 2026: "in the beginning we should see the data bouncing around the pulsecore as it fills." Each datum crosses π radii a flip at 𝒞→, and a step of the fill is a flip, so drawn along its true path through a step (the path segments above, carried over the step's interval) every point scribbled a line round the whole sphere and the Pulsecore read as a tangle of streaks. From 8.6 the scene draws the data on the screen's own clock (flyGas() scene3d.js), a display choice of the same kind as the galaxies' turning cap (Part 6.11):

  • Each point flies straight, one cross-section a Pulse. The author, 15 November 2026: "the data particles bouncing around at the beginning are way too slow ... technically they travel one cross section per pulse so super fast but the visual needs to be faster as well and tie into the actual math that should be going on however we can." The data is light at 𝒞→ and its speed never changes, only its direction (Pulsecore Data Radiance, BPT Part 3.6): π of the Pulsecore's radii a flip, about one and a half crossings (PinpointGas.c). From 8.6 (15 November) the drawing flies each point exactly that far in the time the game draws a flip, measured as the flips arrive (setGasPoints, flipMs, a 0.7/0.3 running mean of the gaps, 40 ms to 4 s): the paced fill draws a flip every half second at level 5, so the points cross at about 6.3 radii a second, three crossings a second, at every size of Pulsecore and at the same pace as the Pulse counter rolls. At the wall each turns back as a mirror turns light, the angle kept: the same law as the simulation's strike. Before 15 November it flew 10 radii a second easing to 1.5 as the Pulsecore packed, a slowing the book does not say; the data is not jammed by its own light.

  • The frames turn with the skin. Every point and its direction turn about the spin axis at the skin's own drawn rate, 1.5·v_∂ radians a second (drawnSpin), the Thirring and Brill–Cohen drag of Bifold Drag.

  • The data doubles as it strikes. The author: "they should double as they bounce." The swarm starts from one datum; each strike of a drawn datum on the skin gives birth to another at the strike, leaving the wall its own way by Lambert's law (as the skin launches data, pinpoint.js), so the swarm goes 1, 2, 4, 8 … as the data multiplies where the skin computes, until it holds the share the fill allows (below).

  • The count drawn is the bits in flight, not the share (15 November 2026). The author: "in a level 202 universe there is going to be full of data when it hits the skin; the 1b data universe is only zinf level." Until 15 November the most points drawn was the share N / χ∂, which is the same at every level, so the opening always showed the Zinf's birth, a few points, however deep the universe. The algorithm that scales, from the Pulsecore Bit Flow (BPT Part 3.6):

    1. Bits in flight at the step: B = N · 4^(L−Lm) · 2^L, the simulation's data within (N model cells, each standing for 4^(L−Lm) true cells) times the 2^L bits a cell carries a Rhythm (Bits per Pulse), with the true level L (gasBits, set where the fill's step hands the scene its density).
    2. Points shown = the smaller of B and the point budget, the simulation's max (cells / 2π, 2,608 at 128 cells across). At level 0 that is 4, 16, 36 points, the Zinf's own birth; at level 5 the swarm is whole by the third Rhythm; at level 202 it is whole at the first flip, 4 · 2^202 bits in four cells.
    3. Each point stands for B / shown bits, a share that grows as the Pulsecore fills.
    4. The births follow the count. At a strike the swarm multiplies by up to 2^L (gasMult) toward the points the count allows: at depth one strike fills whatever the first flip did not, at level 0 the doubling the author asked for on 14 November runs a point at a time as the count grows.
    5. The fill's progress is the packing, η_∂ (packLight(), below), in brightness and crowding; the share N / χ∂ no longer governs the number of points.

    The points glow through the glassy skin (additive, drawn over it) and grow with the core's density as before.

  • It erupts from one side (15 November 2026). The author: "when I press start it just keeps rolling for a second and then starts with the data in the middle, the data should erupt from one side of it on the same plane as the harmonics visuals." The first flip now runs on the paced loop's first tick (owed starts at 1 in the Pulsecore phase), so nothing rolls empty, and the swarm's first frame puts every point at one strike on the skin's equator, the plane the torus and its harmonic rings lie in (z = 0 of the spin frame), at the azimuth of the first point the skin seeded. Each leaves it off the wall its own way (Lambert about the inward normal), all in one shot (the author, the same day: "the spray should be fast and it should be like one shot not like a stream"; a first version released them as a stream over the first flip), each already up to a quarter radius along its own line so the shot is a spray from its first frame; it crosses at the Pulse's pace, strikes the far wall and scatters, and the sphere fills from one side.

  • Each point draws its track. The author, the same day: "there should be lines between the points like there was originally." Each point keeps its last two strikes on the skin and is drawn with two lines, from the older strike to the last (at 0.55 of its light) and from the last to where it flies now, so the chords between bounces show as the whole-flip paths did, and grow as the point flies. A thick swarm's lines are each dimmer by 100/n (at least 0.04), its points by 250/n (at least 0.08), linear in the count since 15 November (it was √(120/n) and √(300/n), which left the whole swarm, flying from the first flip now, a white ball), and the points shrink with the Pulsecore as it eases into the hole, so the added light stays lines and points, not a white ball.

The simulation is unchanged: its points fly their full π radii a flip and write the skin at every strike (PinpointGas.step()); the drawing flies the same π radii a flip, spread over the flip's drawn time instead of jumping it in one frame.

Number Where What it is Kind
π radii a drawn flip scene3d.js flyGas() the drawn data's speed: the simulation's π radii a flip, spread over the flip's drawn time (flipMs, measured; 500 ms until measured) PHYSICS (Pulsecore Data Radiance: 𝒞→, never slowing) over a DISPLAY clock (the paced flip)
0.7/0.3; 40 ms–1.5 s; from the 2nd flip scene3d.js setGasPoints() the running mean of the drawn flips' gaps, the start's gap left out DISPLAY
min(B, max); ×2^L a strike scene3d.js flyGas() the points shown are the bits in flight up to the budget; births at a strike multiply the swarm by up to 2^L toward that count PHYSICS (Pulsecore Bit Flow) over a DISPLAY budget
1.5·v_∂ rad/s scene3d.js flyGas() the drawn frames' turn, the skin's drawn turn DISPLAY (Bifold Drag's sense and shape)
N · 4^(L−Lm) · 2^L app.js (the fill's step) B, the bits in flight the scene draws by: the model's data within scaled to true cells, times the bits a cell carries a Rhythm PHYSICS (Pulsecore Bit Flow; Bits per Pulse)
0.034 + 0.03·d scene3d.js flyGas() the points' size by the core's density d, times the core's eased size DISPLAY
2 strikes, 0.55 scene3d.js flyGas() the track drawn behind a point; its older chord's light DISPLAY
100/n, 250/n scene3d.js flyGas() a thick swarm's lines and points dimmed by the count (at least 0.04, 0.08), so the swarm's whole light stays what 400 points give and the packing's white can rise over it DISPLAY

Packed with light, and space by its area (v8.6, 14 November 2026)

The author: "when the pulsecore creates the space layer 1, we should see the pulsecore completely consumed by light as it is completely packed in the theory at that point and that is what creates the outward expansion, actually the expansion of space has to be some kind of math for the data vs the size of the pulsecore"; and, of the area-based law: "the area based law makes sense to me a lot." BPT Part 3.6 now carries two laws (lexicon #1592, #1593):

  • Pulsecore Packing, η∂ = 2N/χ∂ before the Null Nova and η∂′ = N/χ∂ after it: how full of light the Pulsecore is. At one it is all light, at the Null Nova and again at the Data Nova.
  • Space Extent Law, λ_S(r) = √(S(r)/χ∂) = r/r: space is an area of places, so its size is the square root of its count. It bursts out to r₁/r ≈ 1/√2 at the Null Nova, its side then grows 2 cells a Rhythm, the data's reach, at 𝒞→, and it is the full field at the Data Nova.

The game: setCoreDensity() reads the packing from the data within (scene3d.js, this.packing). packLight() draws a white fill inside the skin at opacity η³ and a glow round it at η⁶, eased with a time constant of 0.33 s, during the fill only: white through at the Null Nova, dimmer as the null leaves, packing white again toward the Data Nova. The null's dark haze is held to 0.35·ρ∅ (it was 0.85·ρ∅), under the light. The data's drawn speed runs with the packing, 1.5 + 8.5·(1 − η) radii a second: the first bits race at 10, and the swarm slows as the Pulsecore jams with light. The space torus already followed the Space Extent Law: buildSpace(k) gives the torus an area k of its full one, from setSpace(N/χ∂), so its size is √k.

Number Where What it is Kind
η³, η⁶ scene3d.js packLight() the white fill and the glow by the packing DISPLAY
0.33 s scene3d.js packLight() the light's easing DISPLAY
1.5 + 8.5·(1 − η) radii/s scene3d.js flyGas() the data's drawn speed by the packing DISPLAY
0.35 scene3d.js setNullDensity() the null haze's opacity at full ρ∅ DISPLAY
√(S/χ∂) scene3d.js buildSpace() the space torus's size PHYSICS (Space Extent Law)