How Provably Fair Dice Actually Work — and Why We Publish a Hash Chain for Every Game

A walk-through of SHA-512 commit-reveal dice generation, why it matters for online backgammon, and why 6proclub is the only platform that ships a verifiable hash chain for every game type.

2026-05-04

If you have ever watched a long, painful losing streak online, you have probably had the same thought every backgammon player has had since the first internet client shipped: is this thing rigged?

The honest answer, for almost every site you can name, is you have no way to know. A server somewhere is calling its own random number generator. You have to trust it. The whole stack — RNG, dealer, payout — sits behind a closed door. "Trust us" is the entire fairness model.

We do not think that is good enough, and we have built 6proclub so you do not have to take our word for any roll. Every dice roll, in every game type we ship, is generated through a public commit-reveal hash chain that you can verify yourself, after the fact, with nothing more than sha256 and sha512 and the values we publish at the end of your match.

This post explains how that works, in plain language, and why we believe we are the only backgammon platform doing it across every game type.

The "trust me" problem

A traditional online dice game looks like this:

  1. The server picks two numbers between 1 and 6.
  2. The server tells your client what they are.
  3. Your client animates the dice and you play the move.

That is it. The "randomness" is whatever the server says it is. There is no audit trail. If the operator quietly nudges the distribution against players who are about to win money, you would never know — and neither would a regulator with a quarterly snapshot, because by the time anyone looks, the only evidence is whatever the server chose to log.

This is not a hypothetical. It is precisely the structure that has produced every single online-gaming fairness scandal of the last twenty years.

Commit-reveal, the short version

A commit-reveal scheme is the simplest cryptographic construction that solves this. The idea is:

  1. Before any rolls happen, the server picks a long, secret seed.
  2. The server publishes the hash of that seed (the commit).
  3. The game plays out. The server uses the seed, combined with a per-roll counter and your own contribution, to derive each dice value.
  4. At the end of the game, the server publishes the original seed (the reveal).

Anyone can now take the revealed seed, run it through the same hash function, and confirm the result matches the commit that was published before the game started. Because cryptographic hashes are preimage-resistant, the server could not have changed its mind partway through and produced a seed that hashed to the same commit but generated different rolls.

In other words: the server has to lock in its randomness before it sees how the game will go. That single property is the entire foundation of provably fair gaming.

How 6proclub does it specifically

We use two well-studied hashes, each for the job it is best at: SHA-256 for the commit/reveal verification, SHA-512 for the per-roll derivation. The chain looks like this for every game:

serverSeed       →  random secret, generated at game start
commit           =  SHA-256(serverSeed)            // published BEFORE any roll
roll_n           =  SHA-512(serverSeed : clientSeed : nonce : rollNumber)
                    → reduced to two dice values 1..6

You contribute a clientSeed of your own — usually random bytes from your browser. The server cannot bias the chain against you because each roll depends on your seed, which the server has not seen and cannot predict at the moment the commit is made.

When the game ends, we publish:

  • The original serverSeed.
  • The clientSeed.
  • The roll counter at every step.

You hash the serverSeed yourself with SHA-256 and confirm it matches the commit shown at the start. If it matches, the chain is intact. If the chain is intact, the rolls were determined the moment the game started — before either of us knew how the game would go.

This is the entire fairness contract, and it is enforced by mathematics, not by our promise.

Why "every game type" is the part that matters

You will find a handful of online platforms that publish a fairness mechanism for one product — usually a slot machine or a single dice game. The chain is wired into that product specifically and stops there.

6proclub is the only backgammon platform we are aware of that runs the same verifiable hash chain across every game type we ship — backgammon, war, and every game we add next. When we launch a new game, the fairness layer is not bolted on as a feature; it is the substrate. There is no "we will get around to making this verifiable later." There is no version of our games where the dice or shuffle is not part of the chain.

That is a choice we made about the architecture, and it is the choice we are most proud of.

What you should actually check

When a game ends on 6proclub, open the verify page for that game and look for three things:

  1. The commit. Make sure it was visible before the game started — the timestamp on the commit predates the first roll.
  2. The reveal. Hash the serverSeed yourself with SHA-256 and confirm it matches the commit. (echo -n "<seed>" | sha256sum will do it on Linux.)
  3. The rolls. For each roll, the published derivation should reproduce the dice you actually saw on the board — apply SHA-512 to serverSeed:clientSeed:nonce:rollNumber exactly as we describe on the verify page.

If any of those three checks fails, we have a problem and we want to hear about it immediately. Email us. We will fix the chain or refund the game, in that order.

The point

Trust in online gaming should not be a vibe. It should be a property you can verify with sha512sum and a few minutes of your time. Every other approach is a marketing claim.

We built 6proclub on the belief that the easier we make it for a skeptical player to catch us cheating, the more we earn the right to ask anyone to play here for money. The hash chain is how we keep that promise — and it runs under every game we will ever ship.

Play here. Verify your games. Tell other players what you found.