A public beacon. A new pulse lands every 2 s.
Each pulse is a signed SHA-256 commitment to the pulse before it, to a digest of the live plasma, and to fresh randomness promised one pulse early. Nothing on this page lights up unless a check passed in your browser, and the verifier is one Python script you run yourself.
Emitted and signed by one Ledatic node · observed and Ed25519-signed by a witness machine Ledatic also runs
the band behind this text is a pulse-seeded rendering — decoration, not the beacon. the beacon is the numbers below.
A new pulse lands every 2 s, on even UTC seconds. Its value is the SHA-256 of a short canonical message that names the previous pulse’s value, the digest of the newest plasma frame, and 32 random bytes the operator committed to one pulse earlier; the operator signs that message with a published Ed25519 key. Anyone can walk the chain. One Ledatic node produces it; a second Ledatic machine, the witness, signs what it sees. The format is written down at /entropy/spec.
The 128² MHD grid advances one timestep. Real physics, conservation-checked.
One canonical message names the previous value, the SHA-256 of the newest frame’s 393,216 float32 bytes and where that frame sits in its seeded epoch, 32 fresh random bytes, and the SHA-256 of the next pulse’s random bytes. The value is the SHA-256 of that message, and the operator’s Ed25519 key signs it.
Served by the Ledatic origin through a Cloudflare tunnel; the edge passes each pulse request through uncached. Visible to the world on this page.
An Orszag-Tang vortex on a 128² periodic grid. Ideal-MHD,
Lax-Friedrichs, conservation near machine precision
(Δm/m about 10-13, ΔE/E < 10-15,
∇·B at 10-15 by construction). A pulse does
not hash a picture. It commits to frame.digest, the
SHA-256 of the 393,216 float32 bytes the solver wrote for that
frame, and names frame.epoch_seed and
frame.epoch_frame, so anyone can replay the epoch from
its seed with
tools/plasma/mhd_verify_epoch.rail
and compare digests (replaying frame k takes
k+1 frames; how).
The panel below draws a published frame file for looking at; it is
not the bytes a pulse hashes, so do not check a digest against it.
The solver is deterministic, which is what makes it replayable: a
pulse’s unpredictability comes from its precommitted random
bytes, not from the plasma.
The viewport reads only the density plane of each published
frame — the first 64 KB after the header, min-max
normalized and color-mapped on your GPU. Every kept frame is a
real keyframe from /entropy/frame/current; the
dissolve between keyframes is presentation. If frames stop
arriving, the panel says so: stale within seconds, and after ten
quiet minutes it demotes itself to replay — recorded
pixels, labeled as recorded.
Each frame also ships a signed record:
— press it and the proof runs here, in your tab. It checks the
witness signature over the frame's digest; the solver-state bytes
themselves aren't published, so the tray will say so rather than
pretend it re-hashed them. That record signs the digest of the
solver’s 589,904-byte state file, a different byte string
from the 393,216 bytes behind a pulse’s
frame.digest, so the two digests differ by design.
Pulses land newest-first. Each arriving row is checked against
the one before it — the link glyph fills only when
prev_value_hex matches in your browser, and a break
prints red. Click any row to re-fetch its published record and
compare. The full log of the last 50 lives at
/entropy/pulse/log.
/entropy/pulse/log and
compare each prev_value_hex yourself, or use the
one-liner under Verify below.
The witness is a separate machine, and Ledatic runs it too. It
polls the public chain and signs what it sees (pulse id, value,
and the moment it watched) with its own Ed25519 key. It does not
yet check links: it does not sign prev_value_hex, and
its receipts carry chain_verified: null. Because one
party runs both machines, a receipt shows that a value was public
by a given moment, not that anyone outside Ledatic saw it. The
latest receipt is republished below; the site’s edge refuses
any receipt whose signature does not verify, and your browser
re-checks it against a key pinned in this site’s source.
raw receipt: /witness/fleet0/latest
— the signed message is pulse_id|value_hex|witnessed_at
You don’t have to take this page’s word for any of
it. Each pulse carries the previous pulse’s hash in
prev_value_hex; the chain check is pure arithmetic
on public JSON. Pin the witness key once, and every receipt
after that is checkable too. Format 2 pulses also carry a
signature and a precommitment; the panel below checks all four
in this tab, against the operator key pinned in this site’s
source.
not checked yet: this panel runs in your browser
reads /entropy/pulse/log and /entropy/v2/key; the four checks are those of verify_v2.py, specified at /entropy/spec.
curl -sO https://ledatic.org/entropy/verify_v2.py
python3 verify_v2.py --url https://ledatic.org
Fetches the operator key from /entropy/v2/key and the
newest 50 pulses, rebuilds each canonical message and checks its
SHA-256, its Ed25519 signature, its link to the pulse before, and
its precommitment. It needs only stock Python 3.8 or newer: it uses
the cryptography package when one is installed and
falls back to the RFC 8032 reference arithmetic when not. It prints
VERDICT=PASS and exits 0 only when every check held.
Compare the key’s fingerprint it prints with
5780ca472c3db50d, pinned here.
curl -s https://ledatic.org/entropy/pulse/log | jq -e '. as $l | all(range(1; length); $l[.].prev_value_hex == $l[.-1].value_hex)' && echo "chain OK" || echo "chain BROKEN"
Fetches the last 50 pulses and confirms each one’s
prev_value_hex matches the previous pulse’s
value_hex. If anyone rewrote history mid-chain,
the link breaks and you’ll see chain BROKEN.
Pulses aren’t only for checking — you can spend one. Grow a small world from a pulse: the same hash that anchors the chain seeds 32 generations of Conway’s Life, and the whole history folds into one fingerprint anyone can re-derive. The beacon chains what the plasma did; Life chains what a hash implies. Same grammar, run in the other direction.
This is a chain, and the chain holds: every pulse names its predecessor, the links verify, and the checks above are the whole proof. What it gives you about unpredictability is narrower than the word “entropy” suggests, and it is worth being exact about that rather than letting the word do work it has not earned. A format 2 value mixes 32 fresh random bytes committed one pulse early, so nobody outside Ledatic can compute it before it is published. It is not unpredictable to Ledatic: the operator generates those bytes and can see its own next value, it can withhold a pulse, and the witness is run by the same party.
Format 2 was built on 2026-10-18 and has signed the live chain since 2026-10-19 (first format 2 pulse: 9062671). The measurements below are of format 1, the pulses before it, and stay here as its record.
Each format 1 value was the SHA-256 of one simulation frame. Identical frames therefore produced identical values, and the plasma does revisit states. Measured on 2026-08-28 across 162,082 consecutive archived pulses: 96.96% of values were unique, 233 distinct values recurred, and 3.04% of pulses repeated a value that had already been published. The repeats are not scattered. The median gap between two occurrences of the same value is 5,196 pulses, and 86% of gaps fall between 5,000 and 5,500, which at roughly one pulse per second is a period of about 87 minutes.
So an observer who recorded a few hours of the format 1 feed could
expect to see some values again. That ruled format 1 out as a source
of unpredictable randomness, and we would rather say so here than have
you discover it. It does not affect the two things the chain is
actually used for: the links still detect tampering, and release
attestations bind through pulse_id, which is unique and
strictly increasing whatever the value does.
We have measured this but not fully explained it. A recurring set of only 233 states, each appearing about twenty times, is consistent with the simulation passing near a periodic orbit, and also with a frame occasionally being re-hashed rather than re-rendered. Until we can tell those apart we are not going to claim which it is.
for i in $(seq 1 300); do curl -s https://ledatic.org/entropy/pulse | \
python3 -c "import sys,json;print(json.load(sys.stdin)['value_hex'])"; sleep 1; \
done | sort | uniq -d
Five minutes of sampling is usually too short to catch a repeat at
an 87-minute period. The honest way to see it is the archive: pull a
few thousand consecutive pulses from
/entropy/pulse/<id> and count duplicate
value_hex. That is exactly how the figures above were
produced. Over format 2 pulses the count should be zero; a repeat
there is a failure worth reporting to hello@ledatic.org.