Trust → math · no login · no server trust

Don't trust us. Verify it yourself.

Every page, every framebox, every color on this site is built to be content-addressed and verifiable — recompute it yourself, live. The point is not that we say it's verified — it's that your own browser can recompute the proof, from the page's own bytes, with code you can read. If a single byte were changed, the math would not match. That is the standard: accountability you check, not a promise you accept.

Verify this page, right now

Press the button. Your browser will fetch this page's served bytes, recompute their cryptographic hash (SHA3-512) using the clean-room verifier loaded on this page, and compare it to the value recorded on the chain. Nothing is sent to us; the check runs entirely on your device.

Or flip Verify: ON in the header and click any block or color on any page

For anyone · no code required

How "verify it yourself" works

You don't have to take our word, and you don't have to be an engineer. The whole idea is that the proof is recomputable by you. Here is exactly what the button above does.

Your browser reads the page's own bytes

It fetches the exact bytes this page was served as — the same bytes you're reading.

It recomputes the hash locally

A clean-room SHA3 implementation (open, readable, no external libraries) turns those bytes into a fixed fingerprint. Change one character and the fingerprint changes completely.

It compares to what's on the chain

The fingerprint on record was stamped when the page was published. If your freshly computed fingerprint matches, the page you're reading is exactly the one that was stamped — verified. If not, it's tampered, and the edge would have refused to serve it.

Down to a single box or color

With Verify: ON in the header, click any text block, graphic, or color token on any gold page to recompute just that element's hash. Colors are first-class — change one accent and its stamp changes.

What is a real proof today — and what's still landing

We will never show you a green check we can't prove.

REAL NOW

Whole-page recompute. Your browser hashes the served bytes (SHA3-512) and compares to the chain stamp — a true, reproducible match/mismatch. Per-element & per-color hashes are recomputed live from the DOM so you can reproduce them with the open verifier.

PROOF PENDING

The per-element Merkle root and the publicly-signed root (Ed25519 STH + CH-master counter-anchor + k-of-n witness co-signs) are being published per page. Until then, element panels say "proof pending" — never a fake VERIFIED. The crypto already exists and is being wired in.

For developers · read the verifier, run it offline

Verify the verifier.

The verifier is clean-room, dependency-free, and identical in your browser and in Node. Read it, run it, recompute the hashes yourself — there is no trusted server in the loop, only math you can audit.

Open the source

The kernel and the page verifier are served as readable JavaScript. The record verifier (health-record proof) is the same kernel, used end-to-end.

# the clean-room crypto kernel (SHA3-256/512, Merkle, Ed25519)
/_shared/ch-record-verify.js
# the page/element verifier (canonicalize + verifyLeaf/verifyPage)
/_shared/ch-page-verify.js
# the public RFC-6962 record verifier (pure Python, offline)
/integrity/verify.py

Recompute in the console

Open your browser dev console on any gold page — the verifier exposes its API. Recompute this page's hash, or any element's leaf, yourself.

// whole-page recompute vs the chain stamp
await CHVerify.verifyPage()
// recompute one element's leaf from the live DOM
await CHVerify.verifyLeaf(
  document.querySelector('[data-ch-id]'))
// or hash arbitrary bytes with the kernel
CHVerify.sha3_256(
  new TextEncoder().encode('hello'))

Go deeper

The whole proof, end to end.

The page hash is one leaf. Below is the rest of the chain — the cryptography, the append-only ledger, the public record index, and the live tamper demonstration — each verifiable the same way.

LEDGER

The append-only chain

Walk the hash-linked ledger and recompute the links yourself. Nobody can rewrite the past.

CRYPTO

The cryptography

SHA3, RFC-6962 Merkle inclusion, Ed25519 signatures — what each one proves, and why.

RUN IT

Verify the chain

Recompute a record's Merkle inclusion to the witnessed root, live, in your browser.

TAMPER

Break it on purpose

Alter a byte and watch the proof fail — see exactly what a tamper looks like.

CLAIMS

Every public claim

Each number and attestation we publish, each one one click from its ledger entry.

RECORDS

Public record index

The externally-anchored integrity root over every record, with an offline Python verifier.

Power to the people who check

Find a gap, get rewarded.

We don't ask you to trust an auditor — we don't even ask you to trust ourselves. If you can find a claim that doesn't recompute, an element whose hash doesn't match, or a flaw in the verifier, that's exactly the kind of accountability the standard is built on. The open-reward program puts the power to check — and to be rewarded for checking — in your hands.

How the reward program works → Report something →

Patent-pending — U.S. Provisional 63/921,717