What utc24h is

A public source of random numbers that anyone can verify, without asking our permission and without taking our word for anything.

What it does

Every 10 minutes —the turn— this site publishes a set of random values and, alongside them, the proofs that nobody chose them. The values and their proofs live in signed files, mirrored in public repositories that are not ours.

There is nothing to install, nothing to sign up for and nothing to pay. The page you are reading is the whole site.

Where the number comes from

Every turn is built from two inputs, and we choose neither of them at the moment of publishing:

A seed committed beforehand. It is 32 bytes taken from the operating system's cryptographic generator, the same one your browser uses to open a secure connection. It is fed by the machine's physical noise —interrupt timings, disk activity, the CPU's own generator— and it is not a formula you can guess from the previous value. If the system cannot supply entropy, the emitter aborts the turn: it never falls back to something predictable.
Minutes before the turn we publish that seed's SHA-256 without revealing it. The commitment is anchored and dated. When we later publish the seed, anyone can check it is the same one: changing a single bit would change the already published hash.
A drand round. drand is a public distributed randomness network that emits a signed value every few seconds, on a schedule known in advance. The commitment names the turn's round before that round exists. Nobody can know its value at signing time.

Who produces the drand round

drand is not run by a company: it is run by a consortium called the League of Entropy, today 17 organisations —universities, foundations and security firms, across different countries and jurisdictions:

ChainSafe · Cloudflare · Center for Digital Trust · EPFL · Emerald Onion · DIA · Ethereum Foundation · Kudelski Security · Protocol Labs · QRL · University of Chile · UCL · StorSwift · IPFSForce · Automata · HSLU Hochschule Luzern · CUIT

Each contributes a share, and every round's value is produced by threshold signature: several of them have to agree, and no single one can produce it alone or know it before the others. We are not part of the consortium and have no influence over it: we only read what it publishes, like anyone else.

The current roster and the technical detail are at drand.love.

Given those two inputs the result is a deterministic function: same inputs, same numbers, on any machine and at any time. We add nothing else.

Why you do not have to trust our seed

It is the right question to ask: we generate the seed, and nobody can look over our shoulder to see whether it really came out at random.

You do not have to, because the seed alone decides nothing. The result comes from mixing it with the drand round, produced by a network of independent organisations we do not control. And the ordering is what settles it: we are locked into our seed before the drand value exists. Even if we hand-picked it, we would not know which way to push.

Bending a result would take breaking both at once: choosing the seed and knowing in advance a drand round that has not been emitted yet.

What you can check

Everything. The method is published in full, and there are verifiers in five languages so you never depend on a binary of ours:

that the revealed seed matches the commitment published earlier;
that the drand round is authentic, against the drand network and not against us;
that the numbers follow from those two inputs and nothing else;
that the file declaring them carries our Ed25519 signature.

The four steps sit next to every value: on the front page, the ? on any tile opens the verification of that number, and {} the same check with the code to run it yourself.

The turn's time is the reference

The number comes into existence at the turn's time and is published a few seconds later: the time it takes to read it, sign it and anchor it. Before that time it does not exist, and nobody —ourselves included— can know it or work it out.

That time is fixed in advance and is the same for everyone. It is the only instant the file declares, and the one to look at to know when each value was produced.

Where everything lives

The signed files	One repository per year, with every turn's emission. Nobody ever edits them.
The specification	The file format and the derivation method, complete, in the permanent repository.
The key registry	The public keys each epoch was signed with, in the same permanent repository.
The verifiers	The code in all five languages, to read or to run.

Links to the repositories sit at the foot of every page. They are on different providers on purpose: losing one leaves nobody unable to verify.

How this changes

This system is a constitution that regulates itself. Nobody can know today what will need changing in 2031. What can be done is to write down in advance how it changes without breaking trust, and to be bound by that.

It is the same reason the RFCs exist: a protocol meant to last decades does not rest on the good will of whoever maintains it, but on a public procedure anyone can check was followed. The rule does not protect whoever writes it: it binds them.

There are three instruments, signed and not interchangeable:

Change notice	Published before a planned change. States what changes, why, and which is the first turn running under the new rules.
Publication notice	For what is not planned. It never rewrites anything: it states what is wrong with what was published and stays beside it.
Incident report	Attached to a turn that did not go as it should. It can exist without an emission: the only way to explain a turn where nothing was published.

Reasons come from closed lists of identifiers, not from our prose. That makes the check mechanical and lets the sentence be built in any language — and stops us softening a bad week with wording nobody compares.

That is where the property that makes everything else verifiable comes from: if a change required a notice and the notice is not there, the change is illegitimate, and anyone settles that by looking at dates.

A gap in the record with nothing beside it is an anomaly. Treat it as one.

The full procedure, in spec/notices.md: GitHub · GitLab

What is not here

This is not a promise: it is how the site is built, and you can check it by looking.

There are no user accounts, because there is nowhere to create one.
There is no sign-up and there are no forms: the site is static files.
No money comes in or goes out. There is no payment path and no way to send us anything.
Access is free and anonymous. Nothing here asks who you are.

Responsibility

The values we publish are public and free to use. Whatever anyone does with them is their own exclusive responsibility. We do not take part in, endorse or supervise any third-party activity that uses them, and we have no relationship with those who do.

We publish a number with its proof. That is all.

What it costs and who pays

The service is free and we charge nobody: there are no accounts, no payments, and we take no money from anyone, neither for emitting nor for what is emitted. There are no sponsors and no donations, and there is no way to send us anything even if someone wanted to.

Keeping it running costs little —a modest server and a domain— and that cost does not grow with the number of people watching: emitting a turn costs the same with ten visitors as with ten million. That is why the site does not need anyone to prop it up in order to keep existing.