Caos controlado en CSS: capacidades y límites de la nueva función random()Artículo · digest del 30 de octubre
Bodegón surrealista con fotografías Polaroid en ángulos de rotación orgánicos aleatorios y un cuadrado perfecto regido por las reglas de CSS random().
Artículo3 secciones≈ 7 min

Caos controlado en CSS: capacidades y límites de la nueva función random()

Mira el mundo físico que te rodea: casi no existen líneas rectas perfectas ni superficies matemáticamente estériles. Las hojas se mecen con el viento a frecuencias distintas, unas fotos Polaroid sobre la mesa caen en ángulos arbitrarios y, en la tipografía impresa clásica, los tipos de metal siempre dejaban una inclinación microscópica apenas perceptible. Justo esas pequeñas irregularidades hacen que el mundo analógico se sienta vivo, cálido y tangible.

Ahora abre cualquier interfaz web moderna: rigor milimétrico de píxel, rejillas modulares rígidas, tarjetas idénticas y filas perfectamente alineadas. La web ha sufrido durante años de esterilidad matemática. Y cuando los ingenieros frontend querían darle un toque de «imperfección viva» (playful imperfection), tenían que elegir entre dos malos parches:

  1. Llamar a Math.random() en JavaScript, lo que provocaba saltos en la interfaz durante la hidratación, empeoraba el Cumulative Layout Shift (CLS) y cargaba la CPU del dispositivo.
  2. Tirar de preprocesadores como Sass generando cientos de líneas de CSS inflado con selectores :nth-child(n) escritos a mano para simular rotaciones pseudoaleatorias.

En la especificación CSS Values and Units Module Level 5, el grupo de trabajo del W3C ha propuesto por fin una solución nativa de navegador: la función random(). En un extenso artículo en Smashing Magazine, el diseñador y desarrollador belga Brecht De Ruyte exploró sus posibilidades con ejemplos reales. Veamos cómo funciona esta magia, por qué la aleatoriedad en CSS debe ser determinista y cómo preparar tus estilos para esta nueva etapa.

Anatomía de la sintaxis: límites, unidades y pasos de rejilla

La sintaxis básica de la función parece engañosamente sencilla:

random( <random-key>?, <min>, <max> [, by <step>]? )

Detrás de esa brevedad se esconden reglas estrictas de tipado del motor de renderizado: puedes pasar una clave opcional para compartir semilla, los extremos del intervalo y un incremento discreto con by.

El primer requisito fundamental de la especificación es que los argumentos <min> y <max> deben tener exactamente la misma dimensión de unidad de medida. Puedes pasar:

  • Ángulos: random(-4deg, 4deg) para inclinar ligeramente los elementos;
  • Intervalos de tiempo: random(0.2s, 1.5s) para desincronizar fases de animación;
  • Dimensiones lineales: random(100px, 300px) para variar el ancho de columnas;
  • Números adimensionales: random(0.5, 1.0) para jugar con la opacidad opacity.

Lo que no puedes hacer es mezclar unidades distintas directamente: una expresión como random(10px, 2rem) es un error de sintaxis y el navegador la ignorará. Si de verdad necesitas combinar píxeles y unidades relativas, tendrás que llevarlas antes a un denominador común con calc().

La segunda propiedad potente es el parámetro de paso discreto (step). Sin él, la función devuelve un valor decimal continuo. Pero en sistemas de diseño reales, los márgenes y tamaños casi siempre son múltiplos de un módulo fijo (por ejemplo, 4 u 8 píxeles). El parámetro de paso mantiene el azar dentro de la disciplina de tu rejilla:

.ticket-badge {
  /* Relleno aleatorio estrictamente en pasos de 4 píxeles: 8px, 12px, 16px... */
  padding-inline: random(8px, 24px, 4px);
  /* Retraso aleatorio de animación con pasos de 100 milisegundos */
  animation-delay: random(0s, 1s, 0.1s);
}

Aquí el tercer argumento fija la granularidad del resultado para que cada padding-inline caiga siempre en múltiplos exactos de 4px y los retardos de animación salten de décima en décima de segundo.

En nuestro repaso sobre cómo funciona la aleatoriedad en CSS puro y qué cambiará en la maquetación, ya tratamos el impacto del paso sobre el renderizado. Es el puente perfecto entre el caos y el orden.

El problema de la independencia: cómo las claves salvan los cuadrados

¿Qué pasa si quieres una tarjeta de tamaño aleatorio y escribes esto?

.card {
  width: random(100px, 200px);
  height: random(100px, 200px);
}

Por defecto, cada llamada a random() se evalúa de forma totalmente independiente. El navegador puede generar 184px para el ancho y 112px para el alto, convirtiendo tu tarjeta en un rectángulo alargado imprevisible. ¿Y si querías conservar un cuadrado perfecto 1:1?

Para resolverlo, la especificación introduce claves compartidas (shared keys). La clave actúa como una semilla común (seed): si dos propiedades CSS reciben el mismo identificador de clave, obtendrán exactamente el mismo valor pseudoaleatorio:

.square-card {
  /* La misma clave --box garantiza que el ancho sea igual al alto */
  inline-size: random(--box element-scoped, 100px, 200px);
  block-size: random(--box element-scoped, 100px, 200px);
}

Al compartir --box, tanto inline-size como block-size leen del mismo generador, asegurando una proporción cuadrada exacta para cada elemento.

Fíjate en el modificador element-scoped. Sin él, una clave global --box calcularía un único número para toda la página y todas las tarjetas saldrían idénticas. Con element-scoped le dices al motor: «aísla el generador dentro de cada nodo DOM concreto». Así cada tarjeta tendrá su propio tamaño aleatorio, pero todas seguirán siendo cuadrados impecables.

Estado de soporte y fallback progresivo seguro

A finales de octubre de 2026, random() está en la vanguardia de la estandarización de navegadores:

  • WebKit (Safari): implementación experimental disponible en las builds de Safari Technology Preview;
  • Blink (Chrome / Chromium): incorporada en Chrome 156 Canary tras el flag de funciones experimentales de plataforma web;
  • Gecko (Firefox): en pruebas dentro de la rama Nightly bajo la preferencia layout.css.random-function.enabled.

Como las versiones estables aún se están preparando para activarla por defecto, usar random() en producción exige seguir las reglas del Progressive Enhancement.

Mira este ejemplo práctico para una galería de tarjetas estilo Polaroid:

/* Estilos base para todos los navegadores: presentación limpia y recta */
.polaroid-item {
  rotate: 0deg;
  transition: transform 0.3s ease;
}

/* Mejora progresiva para navegadores modernos con soporte de random() */
@supports (rotate: random(0deg, 1deg)) {
  .polaroid-item {
    /* Ligera inclinación orgánica de cada tarjeta entre -3 y +3 grados */
    rotate: random(--photo-tilt element-scoped, -3deg, 3deg);
  }

  .polaroid-item:hover {
    /* Al pasar el ratón, la tarjeta se endereza por completo */
    rotate: 0deg;
    transform: scale(1.05);
  }
}

Si el navegador entiende random(), aplica una rotación orgánica distinta a cada foto y la endereza suavemente al hacer hover; si no, se queda con la regla base recta y no rompe nada.

En nuestro análisis sobre cómo 12 funciones del CSS moderno desplazan a los preprocesadores y trucos de JavaScript, ya apuntábamos que el futuro de los estilos pasa por llevar el cálculo dinámico directo al motor de renderizado.

Fallback progresivo seguro

Envuelve siempre tus reglas con random() dentro de una directiva @supports. Así garantizas que los navegadores antiguos muestren un diseño limpio y alineado sin errores de parseo CSS ni estilos vecinos rotos.

En cuanto random() entre en Baseline de forma generalizada, la web dejará atrás esa esterilidad plástica artificial para ofrecer interfaces mucho más vivas y orgánicas.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 3