Chapter 2 · Section 3
The Clock: Flips, Pulses and Tempos
The BPT law
BPT Part 1.6 fixes how a universe's own pulses are counted. "One flip of state, 0 → 1 or 1 → 0, is one Pulse Rhythm; one full cycle, 0 → 1 → 0, is one Pulse Tempo and one frame (Local Frame Rate). The Recursive Growth Law and the Rupture Rule count a universe's own pulses in Tempos, full cycles, never in single flips." Bits per Pulse (G) gives what each count carries, b⌂ = 2^(L+1) = 2s/f^L: "a universe's Pulse Tempo carries 2^(L+1) bits and its Rhythm 2^L; the heritage f stretches its time, not its data."
The Rupture Rule, also BPT Part 1.6, gives a universe's life: n↯ = 2^L, where n↯ is the count of "completed Pulse Tempos of the universe, full 0 → 1 → 0 cycles rather than single flips, at the moment it ruptures and seeds its children." "A universe spawns when its own pulse count reaches the UniSphere's capacity at its level."
BPT Part 3.6 (Data Harmonics) places that life on the count. The Pulsecore's fill, its Null Nova and its Data Nova "are the data's own count, and they take no time on the universe's clock." "The data's count goes on past the Data Nova, as Harmonic 2 of its own series, to Harmonic 3 at (1 − 2/3)·2^L = 2^L / 3 of its Tempos ... that count too is beyond time. The universe's life begins at Harmonic 3, the Physical Nova ... 2^L Tempos from the big bang."
The established physics
None: a game method. The clock is the theory's own count.
The game's math
pulseCounterapp.js:3473 counts engine steps. The firstupdateCore()after Start sets it to 1 without stepping (app.js:4525); every later step adds one (app.js:4571). So flips = pulseCounter − 1.- The page shows the universe's own Pulse by the Pulse Mirror (BPT Part 3.6; 8.5, 2026-11-14):
pulseMirror()app.js:69 (8.5) counts up through the fill, floor((pulseCounter − 1)/2) Tempos, to its 1 at the Data Nova, 2^Lm; holds there while the data's count runs on to the Physical Nova; and from the big bang counts down as the data goes home, 2^Lm · √(1 − vacuumNow()), the Tempo at which the fill held as much data as is still out: slowly through the life (about 0.75 of 2^Lm at the End of the Outward Expansion, the vacuum's share near 0.44), held while the decay's matter spirals in, and down with the wells' glow to 0 when the last well is gone and everything has dissipated (the author, 2026-11-14: "the pulse continues until everything has dissipated"; it first reached 0 at the End of the Outward Expansion).updateHud()and the decay's steps refresh it, since the return and the decay run no engine steps.pulseLabel()app.js:81 adds ↑ or ↓ and, for a level model, the true level's count, n · 2^(L − Lm), as a power of two. One Pulse on the clock is one Tempo. (8.4'spulsesShown()showed floor(pulseCounter / 2), the fill and the life added together.) pulseLength = 2app.js:51, "a Tempo is two flips." It sets the ring period ofRingField(app.js:565), the life of a cell painted with the pulse tool, 2·pulseLength flips (app.js:4715), the burst pattern of an imported packet with no parent data (app.js:3425), and two record fields (app.js:3587, 3708). The page has no control for it; the input it reads (app.js:50) is not on the page, so it is fixed at 2.- During the fill the data counts Rhythms, r = pulseCounter − 1 (8.5 app.js:537, 4910), its Tempo floor(r/2). (8.4 counted n = floor((pulseCounter − 1)/2) Tempos.)
universePulses()app.js:4261 is the universe's own Tempos since the Data Nova: floor((pulseCounter − birthFrame)/2), wherebirthFrameis the frame of the Data Nova (app.js:5305). After the End of the Outward Expansion it is held atlifeEndTempo().physicalTempo() = ceil(2^Lm / 12)(8.5 app.js:4579; 8.4's app.js:4319 had ceil(2^Lm / 3)), the Physical Nova, counted from the Data Nova: 2^Lm/3 cells of reach past it, at four cells a Tempo.lifeEndTempo() = physicalTempo() + 2^Lmapp.js:4320. The End of the Outward Expansion comes whenuniversePulses() ≥ lifeEndTempo()(app.js:4618).uni.rupturePulses = 2^Lm(app.js:4285,U.rupturePulses()universe.js:245).
A desktop at level 6 (Lm = 6): the Null Nova at pulseCounter 92 (Rhythm 91, Part 2.4), the Data Nova at 129 (Rhythm 128, the end of Tempo 64), the Physical Nova at 129 + 2·6 = 141, the End of the Outward Expansion at 129 + 2·70 = 269. The clock climbs to 64 ↑ at the Data Nova, holds 64 to the big bang, rolls down to about 48 ↓ by the End of the Outward Expansion and reaches 0 when the decay has taken everything home. A phone (Lm = 4): Null Nova at 24, Data Nova at 33 (Tempo 16), Physical Nova at 37, End of the Outward Expansion at 69. (Under 8.4's fill, (n + 1)² in Tempos, the same level-6 run had them at 363, 511, 555 and 683, and the clock ended on 341.)
The pace of play is separate from the clock (start() app.js:4801 and startLoop()). In the "fast" pace a 50 ms tick owes rate steps: during the fill rate = max(1, novaRhythm(Lm)/400) (8.5 app.js:5193), at most a flip a tick, so the fill's 2^(Lm+1) flips play in about 6 s at level 6 and 3 s at level 5, the data's count that is no time on the physical clock (8.4: max(1, 2·novaTempo(Lm)/400), about 20 s); during the life rate = min(4, 2·lifeEndTempo()/2000) (app.js:4881), about 100 s. Between steps the universe moves in slices at most every 90 ms, and a slice is skipped when it would reach 0.97 of a step. Each step or slice then waits as long as it took. In the "max" pace the rule runs as many steps as fit in 14 ms, at most 64, before drawing (app.js:4859). The slider pace runs one step every (min + max − value) ms of the slider, with 50, 1000 and 100 as fallbacks. In every pace each step runs and every count is the same; only the wall time changes. At Lm ≤ 6 the life's rate stays far below 4 steps a tick: the largest life, 2·70 = 140 flips, gives 0.07 steps a tick.
The method, in plain steps:
pulseCounter counts flips; the first step after Start only starts the clock
while the Pulsecore fills: r ← pulseCounter − 1 Rhythms, the data's count
Pulse shown ← ⌊r / 2⌋ ↑, rising to 2^Lm at the Data Nova the Pulse Mirror
in the universe: t ← ⌊(pulseCounter − birthFrame) / 2⌋ Tempos since the Data Nova
the big bang at ⌈2^Lm / 12⌉; until then the Pulse shown holds at 2^Lm, the universe's 1
then Pulse shown ← 2^Lm · √(1 − the vacuum's share) ↓, the data still out:
about ¾ of 2^Lm at the End of the Outward Expansion, 0 when the decay's last well is gone
the pace only decides how many steps a tick shows; every step always runs
The code:
// public/game-v8.5-claude-1/app.js:69 pulseMirror(), the Pulse Mirror (2026-11-14)
function pulseMirror() {
if (!uni) return { n: Math.floor(pulseCounter / 2), dir: 0 };
if (pulseCounter === 0) return { n: 0, dir: 0 };
const top = uni.rupturePulses;
if (epoch !== 'universe') return { n: Math.min(top, Math.floor((pulseCounter - 1) / 2)), dir: 1 };
if (decayed || (decaying && decaying.stage === 'field')) return { n: 0, dir: 0 }; /* everything has gone home */
if (physStart === null) return { n: top, dir: 0 }; /* the data's count past the Data Nova, beyond time: at its 1 */
const out = Math.max(0, 1 - vacuumNow()); /* the data not yet home */
const n = out <= 0 ? 0 : Math.max(1, Math.round(top * Math.sqrt(out))); /* 0 only when the last bit is home */
return { n, dir: n > 0 ? -1 : 0 };
}
// public/game-v8.4/app.js:4261 universePulses()
function universePulses() { if (epoch !== 'universe') return 0; const n = Math.floor(Math.max(0, pulseCounter - birthFrame) / 2); return ruptured && uni ? Math.min(n, lifeEndTempo()) : n; }
// public/game-v8.5-claude-1/app.js:4579 physicalTempo()
function physicalTempo() { return uni ? Math.ceil(uni.rupturePulses / 12) : Infinity; }
// public/game-v8.4/app.js:4320 lifeEndTempo()
function lifeEndTempo() { return uni ? physicalTempo() + uni.rupturePulses : Infinity; }
// public/game-v8.4/app.js:4618
if (uni && epoch === 'universe' && !ruptured && !reverse && universePulses() >= lifeEndTempo()) { rupture(); return; }
In the game
The clock is on the readout from the first frame. "Pulse:" (index.php:71, and again in the controls at index.php:130) shows pulseLabel(), the universe's own Pulse, with the tooltip "The universe's own Pulse (the Pulse Mirror): it counts up ↑ through the Pulsecore's fill to its 1 at the Data Nova, 2^L Tempos, and back down ↓ as its data goes home, through its life and its decay, to 0 when everything has dissipated." The Tempos line (index.php:71, tooltip "Own Pulse Tempos (full 0 → 1 → 0 cycles) out of 2^L, the Rupture Rule") changes with the epoch (updateHud() app.js:2130): during the fill it shows the data within against the skin (Part 2.4); from the Data Nova to the Physical Nova it reads "the data's count n / ⌈2^Lm/12⌉ · beyond time"; from the big bang it reads "n − physicalTempo / 2^Lm since the big bang." The state label reads "State: Pulsing" while the clock runs (app.js:4529, 4564).
The Bits line (index.php:73) turns the clock into data, as Bits per Pulse does. Before Start it reads the painted lit cells × 2^(L+1) "in the Pulsecore"; after Start, every flip so far × 2^L (app.js:2136–2137). Its tooltip: "every flip is one Rhythm and carries 2^L bits (Bits per Pulse, ch 1)."
The player controls the pace, not the clock. Start and Pause (index.php:97–98) run and hold it. The Speed menu (index.php:133) offers "slider pace," "paced · the filling in ~20 s, the life in ~100 s" (the default) and "max · the rule flat out," with the tooltip "The physics is the same at every speed." The Pace slider, 50 to 1000 (index.php:132), sets the slider pace. Reverse steps the clock back one flip at a time (Part 2.13).
On a desktop at level 28 with the default pace (Lm = 6), a run reads 64 ↑ · 2^28.0 at the Data Nova, about 6 seconds in; holds there to the big bang; reads about 48 at the End of the Outward Expansion, about 100 seconds after that; and reaches 0 at the end of the full decay.
The scale model
The clock is a scale model. The true life is 2^L Tempos (2^28 ≈ 2.68×10⁸ at level 28); the drawn life is 2^Lm (64 on a desktop). One drawn Tempo of life stands for 2^(L−Lm) true Tempos. scaleModel() keeps the true value as uni.trueRupture (app.js:4284), and the readouts quote it.
Where the game and the theory differ
- BPT puts the fill, both Pulsecore novas and the data's count before Harmonic 3 beyond time, off the universe's clock. The game shows them on the Pulse counter as the rising half of the Pulse Mirror, and marks the data's count past the Data Nova in the Tempos line ("· beyond time").
- The Bits line multiplies the drawn flips by the true level's 2^L bits a flip. It does not apply the scale model's factors: each drawn cell stands for 4^(L−Lm) true cells and each drawn Tempo for 2^(L−Lm) true Tempos, so at L > Lm the line counts the bits of the drawn field at the true level's rate, not the bits of the true field.
Fixed numbers
| Number | Where | What it is | Kind |
|---|---|---|---|
| 2 (pulseLength) | app.js:51 | flips per Tempo | BPT (Part 1.6, Bits per Pulse) |
| 2 (÷2 in pulseMirror, universePulses) | 8.5 app.js:69, 4508 | flips per Pulse | BPT (Part 1.6) |
| 1 (pulseCounter = 1) | app.js:4525 | the first frame starts the clock without a step | METHOD |
| 12 (2^Lm/12) | 8.5 app.js:4579 | the Physical Nova 2^Lm/3 cells of reach past the Data Nova, four cells a Tempo | BPT (Part 3.6, Data Harmonics and the Pulse Mirror) |
| 2^Lm | app.js:4285, 4283 | the life in Tempos | BPT (Part 1.6, Rupture Rule) |
| 50 ms | app.js:4900 | the tick of the fast pace | DISPLAY (pace only) |
| 400, 2000 | app.js:4878 | ticks for the fill and for the life | DISPLAY (pace only) |
| 1 in max(1, …), 4 in min(4, …) | app.js:4880–4881 | least and most steps a tick | DISPLAY (pace only; 4 never binds) |
| 90 ms, 0.97 | app.js:4892 | slice spacing and the last share a slice may take | DISPLAY (pace only) |
| 14 ms, 64, 0 ms | app.js:4859, 4825 | the max pace's budget, batch and interval | DISPLAY (pace only) |
| 50, 1000, 100 | app.js:4903–4904 | slider fallbacks, ms | DISPLAY (pace only) |
| 2 (owed ≤ 2) | app.js:4884–4886 | steps held while matter runs on its own thread | DISPLAY (inactive: the thread is off) |
Measured
The fast pace's "keeps half of every second" rule rests on a measurement the comment records (2026-10-28): about 0.4–0.5 s of physics a flip after the big bang, a step every 0.6 s, on a desktop.