Are online backgammon dice rigged?

No, and you do not have to take our word for it. In a completed online match every roll comes from inputs committed before play: we publish a commitment to our secret seed, both players' apps commit to a chain of their own, and each roll then spends a fresh link from each side, the player to move publishing first and the opponent releasing only after that is locked in. No die exists until both sides have contributed, so nobody, ourselves included, can pick a die, swap it or quietly roll it again. That holds for the value of a completed roll and goes no further: a cancelled match, a message that never arrives and whose clock ran out all sit outside this proof. Anyone can re-derive every roll of a finished game from the published record on this page, and confirming that the record is your own match is the step that belongs to the app, which holds the values your device locked before play. The dice are never generated on your phone and are never adjusted to help or hurt a player, manage games or influence outcomes.

Why do I seem to get worse dice than my opponent?

Because human memory is biased: painful hits are remembered, routine rolls are forgotten. Over a single game, dice luck genuinely varies, that is backgammon. Over many games it evens out precisely, and the players who win consistently are the ones making better decisions with the same distribution of rolls. Our probability guide shows what the real odds look like.

Can my opponent cheat or manipulate the board?

No. The server is the only authority on the game: it generates the dice, validates that every attempted move is legal, and applies it to the official board. A modified client cannot submit an illegal move, the server simply rejects anything the rules do not allow, and both players' boards are continuously verified against the server's with a cryptographic hash on every update.

How does matchmaking stay fair?

Ratings use the Glicko-2 system, a modern refinement of Elo that tracks not just your strength but how certain the system is about it. Matchmaking pairs you with opponents of comparable rating, so wins come from outplaying peers, not from farming newcomers.

Fair Dice, Fair Play

Every backgammon player who loses to a last-roll double has wondered it: are these dice fair? It's the right question to ask of any backgammon app. Here is exactly how our dice are generated, why nobody, including us, can tilt them, and how the rest of the game is kept honest too.

Verify Any Finished Game Yourself

Talk is cheap, so here is the part you can run yourself. When a match ends we disclose its server seed, the commitment we published before the first roll, and every link each side contributed along the way. Paste that reveal bundle below, or look the game up by its ID, and this page re-derives every single die from that record, the exact same computation our servers ran, then shows you roll by roll whether the stored values match. You do not have to take our word for any of it: the arithmetic is open and anyone can repeat it. The one thing this page deliberately will not do is hand out a green "provably fair" badge, because it cannot honestly earn one. It never sees the values your own device wrote down and locked before the first roll, and a record whose chain was replaced wholesale by a careful forgery re-derives here just as flawlessly. Only a byte-for-byte comparison against what your device locked can rule that out, and only your app holds those values. So "consistent" is the honest ceiling on this page, and the strongest verdict is the one the Verify screen in the app can give you.

Reveal bundle (JSON)

The bundle exposes only fairness data, seeds, the commitment, nonces and dice. No player names or accounts are involved.

Game ID

We look up only that game's fairness fields, never any player identity.

Commitment published before play (optional)

When the app's Verify link opens this page it carries the commitment along, so you can hold it against the one inside the record. It does not change the result below: the copy that was locked before the first roll exists only on your device, and comparing against that copy is what the check inside the app does.

Your client seed (optional)

The client seed your app recorded at game start, carried here so you can hold it against the seeds the record discloses. Like the commitment, it does not change the result below: the locked copy lives only on your device, and matching it against that copy is the in-app check's job.

The Dice: Provably Fair, Rolled on the Server

Every roll in a completed online match is produced on our game servers, and it is provably fair in a way you never have to take on trust. Before the first roll we publish a commitment to the secret seed the dice will come from, and both players' apps commit to a private chain of their own; all of it is frozen together into one record before anyone rolls. Every roll then spends one fresh link from each side's chain: the player about to roll publishes theirs at the start of the turn, the opponent releases theirs only once that is locked in, and the die is derived last. So the final unknown input to any die always sits on the other side of the board. Opening dice are no exception, neither one exists until both sides have contributed. Each die is therefore a deterministic result of values committed in advance: nobody, ourselves included, can pick a die, swap it for another, or quietly roll it again. That is a claim about the value of a completed roll and it stops there: whether a match gets cancelled, whether a message arrives, and whose clock ran out all lie outside it. The tool above re-derives every die of a finished game from the published record, arithmetic anyone can repeat. What it cannot do is confirm that the record is your match, because that takes the values your device locked before play and only your app holds those, so that last step happens on the Verify screen in the app.

Just as important is where the roll happens. The dice are never generated on your device, your phone only displays a roll the server has already made. That single design decision eliminates the whole family of dice cheats: a modified app can't reroll, a lag spike can't duplicate a throw, and no client-side trick can peek at the next number, because the next number is not on your phone to be read: it is derived on the server, and only once both sides have released their link for that turn.

And the rolls are never adjusted. There is no "engagement curve", no comeback mechanics, no boost for players on losing streaks. The generator neither knows nor cares who is winning.

The Board: Verified on Every Single Move

Fair dice would mean little if the board itself could drift or be tampered with, so the game runs on a strict server-authoritative model. Your device never tells the server what the board looks like, it only sends your intent ("move this checker from the 13-point to the 8-point"). The server checks that move against the official rules and the official board; illegal moves are simply rejected, no matter what a modified client claims.

Then comes the double-check: with every state update, the server broadcasts a compact fingerprint (hash) of the true board position. Your device computes the same fingerprint from its local board and compares. If even a single checker differs, the client discards its copy and re-synchronizes from the server. Both players are therefore provably looking at the same game at all times, desyncs self-heal in one round-trip, and there is no window in which a stale or manipulated board can be played on.

The Opponents: Glicko-2 Matchmaking

Fairness is also about who you face. Ratings here use Glicko-2, a modern successor to Elo that tracks both your playing strength and the system's confidence in that estimate, so new players converge quickly to their true level instead of spending fifty games being stepping stones. Matchmaking pairs you against opponents of comparable rating, and ranked results feed back into it after every game.

The result: when you win, you outplayed a peer. When you lose, there's something real to learn, usually in the strategy guides.

What Fair Dice Actually Feel Like

Here's the uncomfortable truth: genuinely random dice feel streakier than most people expect. Real randomness produces four doubles in a row, entry dances against a one-point board, and last-roll miracles, at exactly the frequencies probability predicts. A 17/36 shot missing twice in a row happens more than a quarter of the time. Memory keeps the outrages and discards the routine, which is why every experienced online player has a "rigged dice" story and no statistical audit has ever backed one up here.

If you want to calibrate your instincts, the probability basics guide lays out the real numbers, 36 combinations, hitting odds at every distance, entry chances from the bar. Knowing that any specific number shows up 11 times in 36 turns "impossible luck" into "Tuesday".

Want the deeper technical version, generator classes, how the commit-reveal proof works, and the psychology of "rigged" streaks? The blog has it: how server-side RNG actually works.

Our Commitment

Server-generated, provably fair dice: never rolled on a device, never adjusted for any player or situation, and derived from inputs both sides commit to before the first roll, so every die re-derives from the published record once the game ends and the app can confirm the match was yours.
Rule enforcement at the source: every move validated by the server; modified clients gain nothing.
Continuous board verification: hash-checked on every update, self-healing on any mismatch.
Skill-based pairing: Glicko-2 ratings and rating-based matchmaking.

Fair dice mean the only edge left at the table is skill, and skill is learnable. Start with the rules, sharpen it with strategy, and test it live: the table below is free, in your browser, no install needed.