Universe Data: the .ud packet
A universe is its level, its genesis, its pinpoint and its rule; everything after its first pulse is replay. That is the Universe Packet (G) of Binary Pulse Theory, chapter 8 Part 8.1, and .ud is its file: the seed, and optionally what the seed produced, in typed chunks that anyone can replay and check. The game writes one from the Lineage panel with Export .ud.
1. The file
"UD01" 4 bytes: the magic, Universe Data, format 1 chunk · chunk · chunk … each: TYPE (4 ASCII bytes) · LENGTH (uint32, little-endian) · PAYLOAD
| Chunk | Payload | Required |
|---|---|---|
SEED | JSON, UTF-8, canonical: the level, the grid, the rule and the genesis Γ, written the same way by every writer (§2) | yes |
PINP | the pinpoint Π: one bit per cell as a quadtree with null pruning (§3) | yes |
HEAD | JSON, UTF-8, free-form: the engine, ids, parent, who and when, and the derived figures (§2) | yes |
LIFE | JSON: what the replay produced — novas, wells, mergers, crystals, strings, the census against the law, credits, the children offered (§4) | no |
LINE | JSON: the lineage, parent universes back to the genesis (§5) | no |
HASH | 32 bytes: SHA-256 over the SEED and PINP chunks, type, length and payload included. The packet's id (§6) | yes |
Unknown chunk types are skipped, so the format can grow. Order is SEED, PINP, HEAD, then the rest, HASH last. Media type application/vnd.pulsecore.ud; the first four bytes, UD01, identify a packet and its format version.
2. SEED and HEAD: the level, the genesis, the rule
{"level":6,"rows":256,"cols":256,"rule":"binary-pulse-theory v5",
"genesis":{"f0":1.01837,"f":1.01061,"C":0.955124,"a_f":0.812369,"a1":0.449,"a2":0,"q":0.75,"thetaDeg":37,"axisDeg":119,"massRatio":1000000,"aniso":0.45}}
Exactly these keys in exactly this order, no spaces, every number to six significant figures, whole numbers without a point, no exponent between 10⁻⁶ and 10²¹: the way JavaScript prints a number, which packet.php reproduces. The seed is what the id covers, so the browser's export and the server's packet of the same universe have the same id, and two universes with the same seed are the same universe.
| Key | Meaning |
|---|---|
level | L, from the Rupture Rule; the field is 4·2^L a side |
rows, cols | the field's size; the pinpoint is encoded on the smallest power-of-two square that holds it |
rule | the rule R by name: "binary-pulse-theory v5" — perpetual reversal, bifurcation at exposure 1, fold when enclosed, as the Rules page states them |
genesis | Γ: f0, f, C (⟪C⟫), a_f, a1, a2, q, thetaDeg, axisDeg, massRatio, aniso |
| Key | Meaning |
|---|---|
ud, format | format version 1, "Universe Data" |
level, rows, cols, genesis | as in SEED, plus the derived figures: s (the dilation depth), zinf, rupture_pulses, law_progeny |
engine | which program ran it and its version, so two replays can be told apart |
universe_id, climax_group_id | the record's ids at pulsecore.one, when it was saved there |
parent | the parent universe's id and level, and which of its children this is; null for a genesis |
created, player, site | when, who, where |
3. PINP: the pinpoint as a quadtree
node = 00 empty: every cell null
11 full: every cell lit
01 mixed: four children follow, NW NE SW SE, each a node
a single cell is 00 or 11
bits are packed most-significant first; the last byte is padded with zeros
This is the native BPT encoding. The field at level L is 2^(L+2) a side, so it is a quadtree of exactly L+2 levels, mirroring the doubling. The void costs nothing: a region that was never painted is two bits however large. A painted block is two bits. A level 6 pinpoint of a few hundred painted cells is a few hundred bytes; the same field as a bitmap is 8 KB, as JSON 130 KB. No general-purpose compression is applied, so a packet can be read with nothing but this page.
4. LIFE: what the seed produced
| Key | Meaning |
|---|---|
own_pulses | pulses from the Data Nova to where the record stops; birth_frame the frame of the Data Nova |
novas | each: index, own pulse, name (the NOVA set), class, scale S, flips and capacity at overflow, centres, well masses |
well_frames | the own pulse at which each well formed: the census in time |
mergers | each: the wells, the child's a_f and axis, the pulse |
finds | crystals (depth, period, wells, place), strings (length, width, place), spins born, with rarity and pulse |
census | wells formed, law the Progeny Count expected, fold_wells, folds |
ruptured, credits, children | whether the final well formed; the credits; the children offered, each a genesis |
LIFE is a claim. Replaying HEAD and PINP under the named rule must reproduce it; a LIFE that replay contradicts is rejected. That is what makes depth provable.
5. LINE: the lineage
An array from this universe's parent back toward the genesis, each entry { universe_id, level, hash }, hash being the parent packet's HASH when it is known. A lineage is a chain of .ud files each naming the one it came from; the Zinf chain at level 0 is the shortest link repeated.
6. HASH: the packet's id
Hashed as the chunks stand in the file, type and length included, so the id is stable across tools. Two packets with the same id are the same universe: the same seed under the same rule. HEAD, LIFE and LINE are not hashed, because they name who wrote it and what it produced, which can be regenerated and extended without changing which universe this is. The server also keeps a genesis key, the SHA-256 of the SEED text alone: every universe with the same level and genesis shares it, whatever its pinpoint, and that is a family.
6a. Compiling packets
Same id: the same universe wherever it was run; compiling them is verification, two replays that agree, the longer LIFE kept. Same genesis key: a family, every universe played at that level and origin; compiling them is the census at that genesis, which Nova Data shows for any universe's family. Same lineage: a tree, every packet whose LINE leads back to one genesis packet; credits and depth sum down it, and the Zinf chain is the shortest link repeated.
7. The master packet
Level 202. Γ as chapter 6 and Part 9.3 give it. R as the book states it. Π unknown. Three of four chunks can be written today; the search for the fourth is what the low-level universes run inside this one are for. The Ten-Second Level (G) is how far a processor stands from replaying it: the largest level whose whole life it replays in ten seconds, each level eight times the work. Measured on one core of this server on 13 October 2026: level 7, 195 levels behind. The figure is kept at ten-second.json and shown on Nova Data.
8. Reading, writing and continuing one
When a universe forms its final well the server writes its packet from the record, the sealed pinpoint saved at Start and everything the tables hold, into /public/packets/, and the universe's page on Nova Data offers it. The browser's Export .ud gives the same id for the same universe. A packet can be rebuilt later, when finds arrived after the close or a parent's hash became known.
Lineage → Import .ud opens a packet: the panel takes its genesis, the field takes its pinpoint, Lineage names its parent. Start replays it from the seed, so a universe nobody finished can be finished by anyone, and if the packet closed with children they can be played at once, each child naming the packet's id as its parent. A universe's page has Open in the game, which is /game/?packet=<file>. At these levels replay is seconds, so nothing but the seed needs to be kept to continue; a saved-state chunk for very large levels is an optimization for later.
pulsecore.one/ud/ is the PulseCore Universe Data player: drop a .ud on it to see the seed, the pinpoint, the life and the line, check the id, download it, or send it to the game, where the Speed control's max runs the rule flat out so a whole life plays in seconds. A server-written packet opens at /ud/?packet=<file>.
The module /public/game-v5/packet.js has canonicalSeed, encodePinpoint, decodePinpoint, buildPacket and parsePacket, and works unchanged in a browser or in Node; includes/packet.php writes the same bytes on the server. parsePacket returns verified: true when the HASH matches.