This site allows you to secretly roll dice with your untrusted enemies in a way that should ensure that no set of the players can influence the outcome. Even if all of the other players are colluding, as long as there is one honest player, then the results should be fair. The server is also untrusted and not involved other than routing messages between the players, who establish a group session key using Diffie-Hellman so that they can have end-to-end encryption of the actual dice rolls. The players have four verification words that can be used out-of-band to verify that their actual public key was used to establish the session key, which protects against the server or a MITM attempting to sneak in a fake key for a player.
To understand how it works, consider a thought experiment of how you would flip a coin with an unscrupulous person on the phone. You can't trust them to flip the coin and tell you the result. Likewise they don't trust you to flip the coin.
You could both flip a coin and have a rule that if the two coins are the same then it is a Heads, and if the two coins are different then the result is a Tails. This is fair, 50% of the time the coins will be the same and 50% of the time they will be different, except that now the issue is who says their result first? If you say you have a Heads, they can lie about their coin and effectively determine the result of the coin flip.
So what is necessary is a way to commit to the value of your coin flip, without revealing the actual value. One-way cryptographic hash functions are perfect for this, with a minor caveat -- if you were to publish just Hash("Heads") or Hash("Tails"), then your opponent can precompute both of them to see which you have sent. Instead of hashing just "Heads" or "Tails", each of you hash a large cryptographicly secure random number. And then the bottom bit of the random number is used to determine your coin flip: 0 is Tails, 1 is Heads. The bottom bit of your number and their number are XOR'ed and the result is used to determine the final coin flip. Now it doesn't matter who reveals first since the other party can't change their result.
(Another approach is that if you have exchanged public keys with your enemies, you could sign your coin flip (along with some random padding as before to ensure they can't guess it) and send just the signature first. Then both of you reveal the padding and the coin flip, and can verify each other's signatures, although this requires more math and key management than the simple XOR and hash)
The nice thing about this cryptographic coin flip techinque is that it generalizes to an arbitrary number of people on the phone call. Even if the rest of them collude to come up with random numbers that XOR to their desired value, they don't know if your random number will flip that result or not.
This way no outside party can determine what the result is for our coin flip, not even if they have code execution on the server. They can try to sneak a fake player into the round, but you can use an out-of-band channel (like your voice chat) to verify the public portion of each player's Diffie-Hellman key. If the four words don't match, then something has tried to MITM the group key establishment.
If a dishonest player is colluding with the server, they could team up to send fake commitments for another player since the cheater can leak the shared secret and then the server can fake the source id. This is difficult since the honest player has no way to deny that they sent the messages.
Instead we've imported the public key management from secret.cards that generates an ephemeral signing key as part of joining the room and shares the key as part of setting up the shared secret. Then all messages from that player to the room are signed with that player's key and then encrypted with the shared secret. The other players can verify that the messgae is encrypted with the correct secret (using AES-GCM) and then verify that the signature on the message matches the claimed source that sent it.
You can checkout the source code and add new dice to the docs/dice.json file. Eventually there should be a drag-and-drop way to add new images and sets.