Empecemos con la pregunta que todo jugador de backgammon online se ha hecho al menos una vez, normalmente justo después de sacar un 6-1 cuando necesitaba cualquier otra cosa: ¿están amañados los dados?

Es razonable sospechar. Así que en lugar de decirte “confía en nosotros”, vamos a mostrarte exactamente cómo funcionan nuestros dados — en lenguaje sencillo para todos, y con el código real para los escépticos que escriben software para ganarse la vida. Al final sabrás más sobre nuestros dados que sobre los de madera que tienes en el armario.

Los dados se tiran en el servidor, no en tu teléfono

Cuando tocas para tirar, tu dispositivo no decide nada. Envía una petición a nuestro servidor, el servidor genera los dados y te devuelve el resultado. El resultado queda fijado en el instante en que se crea.

Al principio esto suena menos fiable — “espera, ¿ustedes tiran los dados?” — pero es lo contrario. Si los dados se generaran en tu teléfono o en tu navegador, una app manipulada podría simplemente tirar lo que quisiera. Dobles en cada turno. Al centralizar las tiradas en un servidor que controlamos y podemos auditar, ningún participante puede inclinar los dados — ni tú, ni tu rival, ni nosotros en medio de la partida.

Aleatoriedad predecible vs. aleatoriedad criptográfica

Aquí es donde la mayoría de los generadores “aleatorios” fallan en silencio.

Muchos lenguajes de programación incluyen una función aleatoria por defecto que es rápida pero predecible. Parte de un único número (una “semilla”) y a partir de ahí produce una secuencia fija. Cualquiera que descubra la semilla — o simplemente observe suficientes tiradas — puede empezar a predecir lo que viene. Para un juego competitivo donde están en juego los puntos y el orgullo, eso es inaceptable.

No usamos ese tipo de generador. Usamos crypto/rand de Go — la misma clase de aleatoriedad que se usa para generar las claves de cifrado que protegen el tráfico bancario. Se extrae del depósito de entropía del sistema operativo, no puede sembrarse y no puede predecirse a partir de tiradas anteriores. No hay ninguna secuencia oculta que aplicar ingeniería inversa, porque no hay secuencia.

Un par de detalles para los ingenieros que leen esto, vigentes a fecha de Go 1.26 (el lenguaje en el que corre nuestro backend):

La fuente de aleatoriedad no puede cambiarse en silencio por una más débil. A partir de Go 1.26 siempre se usa una fuente segura respaldada por el sistema operativo; nada en nuestro código ni en nuestras dependencias puede degradarla de forma silenciosa.
No hay alternativa a valores adivinables. Si la fuente de entropía del sistema operativo llegara a fallar — algo prácticamente imposible — el programa se cae por completo en lugar de seguir cojeando con mala aleatoriedad. En el peor de los casos el juego se detiene, nunca hace trampa.

La trampa sutil: el sesgo de módulo

Esta es la parte de la que casi nadie oye hablar, y es de donde salen los dados “casi justos”.

Las computadoras producen aleatoriedad en forma de bytes en bruto — números del 0 al 255. La forma ingenua de convertir eso en una tirada de dado es tomar el resto tras dividir entre 6 (“módulo 6”). Parece correcto. No lo es. El rango 0–255 no se divide de forma exacta en seis grupos, así que un par de caras salen un poco más a menudo que las demás. Es un sesgo diminuto, permanente e invisible — pero a lo largo de millones de tiradas se vuelve estadísticamente real. Esa es la diferencia entre dados justos y dados sutilmente cargados.

Lo evitamos por completo. En lugar del atajo del resto, extraemos un único número uniforme entre las 36 combinaciones posibles de dados usando crypto/rand.Int. Por dentro eso usa muestreo por rechazo: descarta en silencio los valores “sobrantes” que sesgarían el resultado, de modo que lo que queda es matemáticamente uniforme. Cada uno de los 36 resultados es exactamente igual de probable. Sin resto, sin sesgo.

El código real

No te pedimos que nos creas sin más. Este es el mecanismo real (Go 1.26):

package dice

import (
	"crypto/rand"
	"math/big"
)

// cryptoRoll devuelve los dados de una única tirada de backgammon.
// Cada una de las 36 combinaciones es exactamente igual de probable, sin sesgo de módulo.
// Los dobles devuelven cuatro movimientos; una tirada normal devuelve dos.
func cryptoRoll() []int {
	// Una extracción sin sesgo sobre las 36 combinaciones [0, 36).
	// rand.Int usa crypto/rand (seguro, respaldado por el SO) y rechaza
	// internamente los valores sobrantes, así que cada resultado es igual de probable.
	// En Go 1.24+, rand.Int no puede devolver un error aquí, así que descartarlo
	// es seguro: crypto/rand.Read nunca da error y hace que el proceso se caiga
	// de forma irrecuperable ante el (prácticamente imposible) fallo de entropía.
	n, _ := rand.Int(rand.Reader, big.NewInt(36))
	i := int(n.Int64())
	d1, d2 := i/6+1, i%6+1
	if d1 == d2 {
		return []int{d1, d1, d1, d1} // dobles → 4 movimientos
	}
	return []int{d1, d2}
}

Para los curiosos: big.NewInt(36) es el espacio completo de los 6 × 6 resultados, y i/6 + 1 e i%6 + 1 dividen ese único número de nuevo en dos caras del 1 al 6.

Los dobles funcionan exactamente como los dados físicos

Una tirada son dos dados. Cuando coinciden — un doble — el backgammon te da cuatro movimientos de ese valor, así que la función devuelve cuatro entradas. Las probabilidades son idénticas a las de un par de dados real: cualquier doble sale 1 de cada 6, y un doble específico (digamos, doble 5) es 1 de cada 36. No hacemos los dobles más raros para ralentizar la partida, ni más comunes para acelerarla. Caen exactamente con la frecuencia que dice la física.

Lo que la tirada deliberadamente no hace

Este es el corazón de la sospecha de “amañado”, así que seamos directos. La función de los dados:

no lee el marcador, el estado del match ni quién está a punto de retirar fichas;
no sabe la apuesta, ni quién eres, ni contra quién juegas;
no tiene lógica de remontada, ni curva de dificultad, ni empujoncito a favor de la casa.

Su única entrada es la aleatoriedad. Su única salida son dos dados justos. Los dados de verdad no saben — ni pueden saber — que necesitabas un 6-1 y en su lugar te salió un 2-1.

La confianza se gana, no se afirma

Podríamos haber escrito simplemente “nuestros dados son justos” y seguir adelante. Preferimos darte el mecanismo y el código y dejar que compruebes nuestro trabajo. Ese es el objetivo de este post: la transparencia que puedes verificar gana a la tranquilidad que tienes que tragarte.

Si alguna vez has jurado que los dados la tenían tomada contigo, estás en buena compañía — a todo jugador de backgammon le pasa. La diferencia es que ahora puedes leer exactamente cómo se fabrican.

Juega una partida y compruébalo tú mismo →

¿Prefieres una app? Consíguela en la App Store o Google Play.