Home / Frontend / Colores CSS modernos: de rgb() a oklch con color-mix y contraste
Colores CSS modernos: de rgb() a oklch con color-mix y contraste

Colores CSS modernos: de rgb() a oklch con color-mix y contraste

21 November 2026 · 25 min de lectura ··

Por qué conviene revisar cómo escribes los colores en CSS

Durante años, el color en CSS se resolvió con tres herramientas: una palabra clave como tomato, un código hexadecimal como #ff6347 y la función rgb() o rgba(). Esas tres siguen funcionando y seguirán haciéndolo, pero el lenguaje ha crecido bastante. Hoy puedes describir un color por su tono, su claridad y su intensidad, puedes mezclar dos colores en el propio navegador, puedes derivar una paleta completa a partir de un único valor y puedes hacerlo todo con una sintaxis más limpia que la de hace una década.

Este tutorial recorre ese camino de forma práctica. Empezaremos por lo básico para fijar el vocabulario, corregiremos varias ideas equivocadas que circulan desde hace tiempo y avanzaremos hacia hsl(), oklch(), color-mix(), las variables CSS y la comprobación de contraste. Cada sección incluye ejemplos que puedes copiar a tu hoja de estilos y probar en el navegador.

Antes de seguir, una nota sobre el estado actual de estas funciones. La mezcla de colores con color-mix() está disponible en todos los motores principales desde mayo de 2023, empezando por Chrome 111, Firefox 113 y Safari 16.2, y figura como característica de Baseline con soporte amplio. Los espacios oklab y oklch también están ya en los motores principales y aparecen en Baseline. En cambio, la versión de color-mix() con tres o más colores todavía tiene soporte desigual, así que en este artículo la trataremos como una curiosidad y no como una herramienta de producción. Siempre que dudes, consulta la tabla de compatibilidad de MDN o de Can I Use antes de apoyar un diseño en una función concreta.

Lo que aprenderás aquí:

  • Cuándo usar nombres, hexadecimal, rgb(), hsl() y oklch().
  • Cómo escribir la sintaxis actual de las funciones de color.
  • Qué diferencia real hay entre opacidad y canal alfa.
  • Cómo mezclar colores y generar variantes con color-mix().
  • Cómo organizar una paleta con variables CSS.
  • Cómo comprobar el contraste y respetar la accesibilidad.

Las cuatro formas clásicas de nombrar un color

Todo valor de color en CSS pertenece al tipo de dato color, y ese tipo se puede expresar de varias maneras. Conviene conocer las clásicas porque las encontrarás en cualquier proyecto heredado.

Palabras clave

CSS define unas 148 palabras clave de color, desde red y blue hasta nombres más exóticos como rebeccapurple, gainsboro o papayawhip. Además existen transparent, que equivale a un negro totalmente transparente, y currentcolor, que toma el valor de la propiedad color del elemento. Son cómodas para prototipos, depuración y demostraciones, pero poco útiles para un sistema de diseño porque no puedes ajustarlas con precisión.

.aviso {
  color: darkslategray;
  background-color: lemonchiffon;
  border: 2px solid goldenrod;
}

Hexadecimal

La notación hexadecimal usa el prefijo # seguido de dígitos del 0 al 9 y letras de la A a la F. Cada par de dígitos representa un canal: rojo, verde y azul, con valores entre 0 y 255. Si quieres repasar cómo funciona la base dieciséis, puedes leer qué es el sistema hexadecimal y cómo usarlo al programar, que explica la conversión paso a paso.

Hay cuatro longitudes válidas, no solo dos. La forma de seis dígitos es la más habitual, la de tres es una abreviación cuando cada par repite el mismo dígito, y existen las variantes de cuatro y ocho dígitos, que añaden un canal alfa al final.

.tarjeta {
  color: #1a2b3c;        /* seis dígitos */
  background: #fa0;      /* tres dígitos: equivale a #ffaa00 */
  border-color: #1a2b3c80; /* ocho dígitos: el último par es el alfa */
  outline-color: #f008;  /* cuatro dígitos: rojo con alfa aproximado de 0.53 */
}

Un error frecuente es creer que los ordenadores “piensan” en hexadecimal. No es así: trabajan en binario, y el hexadecimal es simplemente una notación compacta y legible para las personas, porque un byte cabe exactamente en dos dígitos. Otro error habitual en ejemplos antiguos es olvidar la propiedad y escribir solo el valor dentro de la regla, algo que el navegador descarta sin avisar. Siempre debe haber una propiedad como color o background-color delante del valor.

Funciones rgb() y rgba()

La función rgb() recibe tres números entre 0 y 255, o tres porcentajes. El resultado es el mismo color que daría el hexadecimal equivalente. Con 256 valores por canal hay 256 por 256 por 256 combinaciones, es decir, 16 777 216 colores posibles en el espacio sRGB de ocho bits por canal.

.boton {
  background-color: rgb(34, 139, 230);
  color: rgb(100%, 100%, 100%);
}

La función rgba() añadía un cuarto argumento para la transparencia. En la actualidad ya no hace falta, porque rgb() acepta alfa directamente, como veremos enseguida. Los nombres rgba() y hsla() se mantienen como alias por compatibilidad y no están obsoletos en el sentido de que vayan a dejar de funcionar, pero la forma recomendada hoy es la unificada.

Una aclaración terminológica

Es habitual leer que rgba() es “un selector” o que opacity es “un selector”. Ninguna de las dos cosas es cierta. Un selector decide a qué elementos se aplican las reglas; rgba() es una función que devuelve un color y opacity es una propiedad. Parece un detalle menor, pero usar el vocabulario correcto te ayuda a buscar documentación y a entender los mensajes de las herramientas de desarrollo.

La sintaxis moderna: espacios, barra y alfa

La gran limpieza de las funciones de color llegó con la llamada notación de nivel 4. Las funciones rgb() y hsl() aceptan ahora argumentos separados por espacios y un alfa tras una barra diagonal. Con la sintaxis moderna con espacios el código resulta más uniforme entre funciones, porque rgb(), hsl(), hwb(), lab(), lch(), oklab() y oklch() siguen el mismo patrón.

.panel {
  /* Antigua, con comas */
  background-color: rgba(34, 139, 230, 0.4);

  /* Moderna, con espacios y barra */
  border-color: rgb(34 139 230 / 0.4);
  color: rgb(34 139 230 / 40%);
}

Hay varias reglas que conviene tener claras:

  • Dentro de la función puedes poner espacios con libertad. La idea difundida de que no debe haber espacios “entre nada” es falsa; lo que no puedes hacer es dejar un espacio entre el nombre de la función y el paréntesis de apertura.
  • El alfa es un número entre 0 y 1, o un porcentaje entre 0 % y 100 %. No está limitado a los valores 0 y 1: 0.5 y 0.3 son perfectamente válidos, y es lo habitual.
  • En la forma con comas no se puede mezclar, por ejemplo, un porcentaje con un número en los tres canales. En la forma moderna la validación es más flexible.
  • Se permite la palabra none en la sintaxis nueva para indicar un componente ausente, algo útil en interpolaciones y animaciones.

La notación antigua con comas funciona en todos los navegadores y no hay urgencia por migrar un proyecto entero. Sin embargo, para código nuevo la forma con espacios es más consistente, y mezclar ambas en el mismo archivo solo añade ruido.

Opacidad frente a canal alfa

Aquí se esconde una de las diferencias más importantes del color en CSS, y una fuente continua de errores visuales. La propiedad opacity afecta a todo el elemento: su fondo, su texto, sus bordes, sus sombras y todos sus descendientes. El canal alfa de un color, en cambio, afecta solo a ese color concreto.

Imagina una tarjeta con un fondo oscuro semitransparente y un texto en el interior. Si usas opacity: 0.5, el texto también se vuelve semitransparente, y probablemente deje de ser legible. Si usas un fondo con alfa, solo el fondo deja pasar la luz.

<div class="vitrina">
  <p class="vitrina__texto">Oferta de temporada</p>
</div>
.vitrina {
  /* Opción A: todo el bloque, incluido el texto, se atenúa */
  background-color: rgb(20 30 60);
  opacity: 0.6;
}

.vitrina--alfa {
  /* Opción B: solo el fondo es translúcido */
  background-color: rgb(20 30 60 / 0.6);
  opacity: 1;
}

Hay otras diferencias que merece la pena recordar:

  • opacity menor que 1 crea un nuevo contexto de apilamiento, lo que puede alterar el orden de las capas y el comportamiento de z-index.
  • opacity se aplica al resultado compuesto del elemento, por lo que dos hijos superpuestos se funden entre sí de forma distinta a como lo harían con alfa individual.
  • El alfa en un color es más barato de razonar: sabes exactamente qué parte del diseño cambia.
  • Para animar un fundido de entrada o salida de un componente entero, opacity es la opción adecuada y además suele ser eficiente de animar.

Una regla práctica: si quieres que algo “desaparezca” por completo, usa opacity; si quieres que un fondo, un borde o una sombra sean translúcidos, usa un color con alfa.

HSL: pensar en tono, saturación y luminosidad

El modelo RGB describe cuánta luz roja, verde y azul mezclas. Es fiel al hardware, pero poco intuitivo para los humanos: si quieres un azul “un poco más oscuro”, no sabes qué número tocar. La función hsl() describe el color con tres ideas más cercanas a cómo lo percibimos: el tono (hue), la saturación y la luminosidad.

El tono es un ángulo en la rueda cromática, de 0 a 360 grados: 0 es rojo, 120 es verde y 240 es azul. La saturación es un porcentaje que va de gris a color puro, y la luminosidad va de negro a blanco pasando por el color puro en el 50 %.

:root {
  --tono: 210;
}

.insignia {
  background-color: hsl(var(--tono) 80% 45%);
  color: hsl(var(--tono) 80% 95%);
  border-color: hsl(var(--tono) 80% 30% / 0.5);
}

Con esta forma puedes crear variantes con solo cambiar un número. Un tono más claro es subir la luminosidad, un estado deshabilitado es bajar la saturación, y una paleta analógica es mover el tono unos grados. Para sistemas pequeños es suficiente y muy legible.

El problema de HSL es que su luminosidad no es perceptual. Un amarillo y un azul con la misma luminosidad del 50 % se ven con brillos muy distintos: el amarillo parece mucho más luminoso. Eso significa que no puedes asumir que dos colores con el mismo valor de L tendrán el mismo contraste contra un fondo, y te obliga a ajustar a ojo cada color de la paleta. Esa limitación es la que resuelven los espacios perceptuales.

OKLCH: un espacio pensado para la percepción

La función oklch() usa tres componentes: luminosidad, croma y tono. En el espacio perceptual OKLCH la luminosidad se comporta de forma bastante uniforme, de modo que dos colores con el mismo valor de L tienen un brillo percibido muy parecido, sea cual sea su tono. Es una gran ventaja para construir paletas coherentes y para predecir el contraste.

La sintaxis es sencilla:

.accion {
  /* oklch(luminosidad croma tono / alfa) */
  background-color: oklch(62% 0.19 255);
  color: oklch(98% 0.01 255);
  border-color: oklch(45% 0.15 255 / 0.6);
}

Cada componente significa lo siguiente:

  • La luminosidad es un porcentaje de 0 % a 100 %, o un número de 0 a 1.
  • El croma es la intensidad del color. No tiene un máximo fijo: en la práctica los valores útiles rondan entre 0 y 0.4, y el máximo alcanzable depende del tono y de la luminosidad.
  • El tono es un ángulo en grados, igual que en HSL, aunque los grados no coinciden con los de HSL: el azul de OKLCH está cerca de 260 y no de 240.

Hay que entender bien un concepto: la gama de color. Muchas combinaciones de L, C y H describen colores que una pantalla estándar sRGB no puede mostrar. Cuando esto ocurre, el navegador aplica un recorte o un mapeo de gama para acercar el color al más parecido que sí puede mostrar. En pantallas con gama amplia, como las que usan Display P3, verás colores más vivos que los que permite el hexadecimal, que está limitado a sRGB.

Para sacar partido de esas pantallas sin romper el resto, puedes escribir un valor de reserva y luego sobrescribirlo con una consulta de característica:

.destacado {
  background-color: rgb(0 170 90);
}

@media (color-gamut: p3) {
  .destacado {
    background-color: oklch(70% 0.25 150);
  }
}

Los navegadores que no reconocen una función ignoran la declaración, y por eso basta con escribir antes un valor conocido. Con @supports también puedes probar la función explícitamente:

@supports (color: oklch(0% 0 0)) {
  :root {
    --marca: oklch(60% 0.2 30);
  }
}

Este patrón sirve en proyectos que todavía deben cubrir navegadores antiguos. Si tu público usa navegadores actualizados, puedes escribir oklch() directamente.

Cuándo elegir cada formato

No hace falta elegir uno solo. Una guía razonable:

  • Usa palabras clave para pruebas rápidas y para transparent y currentcolor.
  • Usa hexadecimal cuando recibes colores de un diseñador o de una herramienta que los exporta así.
  • Usa rgb() cuando necesites interoperar con código JavaScript o canvas que ya trabaja en canales de 0 a 255.
  • Usa hsl() para sistemas pequeños con variantes simples.
  • Usa oklch() para paletas de diseño, modos claro y oscuro y cualquier caso donde el brillo percibido importe.

Mezclar colores con color-mix()

La función color-mix() combina dos colores en un espacio de color elegido y con proporciones controladas. Antes se necesitaba un preprocesador como Sass para hacer algo así en tiempo de compilación; ahora el navegador lo hace en tiempo de ejecución, y por tanto puede reaccionar a variables y a cambios de tema.

La forma básica es:

.degradado-suave {
  background-color: color-mix(in oklch, oklch(60% 0.2 250), white 30%);
}

Esto significa: mezcla el azul con un 30 % de blanco usando el espacio OKLCH. Si omites los porcentajes, el reparto es al 50 % cada uno. Si indicas solo uno, el otro se calcula como el complemento hasta el 100 %.

Algunos casos prácticos habituales:

:root {
  --marca: oklch(58% 0.2 260);
}

.boton {
  background-color: var(--marca);
}

.boton:hover {
  /* un 15 % de negro oscurece sin salir de la paleta */
  background-color: color-mix(in oklch, var(--marca), black 15%);
}

.boton:disabled {
  /* mezcla con gris para atenuar */
  background-color: color-mix(in oklch, var(--marca), gray 60%);
}

.boton--fantasma {
  /* un fondo casi transparente a partir del mismo color */
  background-color: color-mix(in oklch, var(--marca) 12%, transparent);
}

El último ejemplo es especialmente útil: mezclar con transparent produce un color con alfa a partir de cualquier variable, algo que antes obligaba a duplicar el valor en versión RGB con alfa.

Hay detalles que debes conocer para evitar sorpresas:

  • El espacio de interpolación importa. Mezclar azul y amarillo en sRGB da un gris verdoso apagado, mientras que mezclarlos en OKLCH recorre el círculo de tonos y produce transiciones más vivas. Para mezclar colores en oklch es habitual añadir un indicador de ruta de tono, como longer hue, cuando quieres controlar por qué lado de la rueda pasa la mezcla.
  • Si los porcentajes suman menos del 100 %, el resultado se vuelve parcialmente transparente en lugar de normalizarse a cien. Es un comportamiento deliberado y útil, pero puede resultar confuso si no lo esperabas.
  • Si suman más del 100 %, se normalizan proporcionalmente.
  • La forma con tres o más colores es todavía una novedad con soporte irregular. No la uses sin un valor de reserva.

Para el modo claro y oscuro, una función cercana es light-dark(), que elige entre dos colores según el esquema activo del elemento. Para que funcione hay que declarar la propiedad color-scheme. Verifica la compatibilidad en tu tabla de navegadores de referencia antes de adoptarla de forma generalizada.

:root {
  color-scheme: light dark;
  --fondo: light-dark(oklch(98% 0.005 250), oklch(20% 0.02 250));
  --texto: light-dark(oklch(25% 0.02 250), oklch(92% 0.01 250));
}

Sintaxis de color relativo

Otra pieza de la familia moderna es la sintaxis de color relativo. Permite tomar un color existente, descomponerlo en sus canales y modificar uno o varios. La palabra from indica el color de origen y dentro de la función puedes usar los nombres de los canales como si fueran variables.

:root {
  --base: oklch(60% 0.18 30);
}

.etiqueta {
  /* mismo color pero más claro */
  background-color: oklch(from var(--base) calc(l + 0.2) c h);

  /* mismo color con la mitad de alfa */
  border-color: oklch(from var(--base) l c h / 0.5);

  /* tono girado 180 grados: el color complementario */
  outline-color: oklch(from var(--base) l c calc(h + 180));
}

La ventaja es enorme: una sola variable de marca produce todos los estados y todas las variantes. El inconveniente es la compatibilidad, que ha mejorado mucho pero es más reciente que la de color-mix(). Si decides usarla, comprueba la tabla de compatibilidad vigente y mantén un valor de reserva para los navegadores que no la reconocen.

Comparada con color-mix(), la sintaxis relativa es más expresiva porque puedes modificar un único canal con precisión, mientras que color-mix() es más sencilla y tiene un soporte más maduro. En proyectos reales conviene empezar con color-mix() y recurrir al color relativo cuando necesites un control más fino.

Variables CSS para organizar la paleta

Un color suelto en una regla se vuelve un problema cuando se repite en cien sitios. Las propiedades personalizadas de CSS, comúnmente llamadas variables, resuelven este problema: defines el valor una vez y lo referencias donde haga falta. Combinadas con las funciones modernas, permiten construir sistemas completos con muy pocas líneas.

Una buena estructura separa dos capas. La primera contiene los valores primitivos, que son colores sin significado de uso. La segunda contiene los tokens de color semánticos, que describen para qué sirve cada color y apuntan a la capa primitiva.

:root {
  /* Capa 1: primitivos */
  --azul-500: oklch(58% 0.2 260);
  --azul-700: oklch(42% 0.17 260);
  --gris-50: oklch(98% 0.003 260);
  --gris-900: oklch(22% 0.02 260);
  --rojo-600: oklch(52% 0.22 27);

  /* Capa 2: semánticos */
  --color-fondo: var(--gris-50);
  --color-texto: var(--gris-900);
  --color-accion: var(--azul-500);
  --color-accion-hover: var(--azul-700);
  --color-peligro: var(--rojo-600);
}

body {
  background-color: var(--color-fondo);
  color: var(--color-texto);
}

.boton {
  background-color: var(--color-accion);
  color: var(--gris-50);
}

.boton:hover {
  background-color: var(--color-accion-hover);
}

Cambiar de tema consiste en redefinir la capa semántica en un ámbito distinto:

@media (prefers-color-scheme: dark) {
  :root {
    --color-fondo: var(--gris-900);
    --color-texto: var(--gris-50);
  }
}

[data-tema="oscuro"] {
  --color-fondo: var(--gris-900);
  --color-texto: var(--gris-50);
}

Con esta técnica, el resto de las reglas no cambia. Si quieres ver cómo modificar el color de un elemento concreto también desde JavaScript, puedes consultar cómo cambiar el color de un elemento h2 con CSS y JavaScript, donde se muestra el enlace entre el DOM y los estilos. Para modificar un tema entero basta con cambiar una propiedad personalizada en el elemento raíz:

const raiz = document.documentElement;

function aplicarTono(tono) {
  raiz.style.setProperty("--tono-marca", String(tono));
}

aplicarTono(145);
:root {
  --tono-marca: 260;
  --color-accion: oklch(58% 0.2 var(--tono-marca));
}

Un par de buenas prácticas ayudan a que el sistema no se degrade con el tiempo:

  • Nombra las variables por su función, no por su aspecto. Un nombre como --color-peligro sobrevive a un rediseño; --rojo-brillante deja de tener sentido el día que el peligro pase a ser naranja.
  • Evita definir colores nuevos dentro de los componentes. Si necesitas una variante, créala en la capa de variables o derívala con color-mix().
  • Documenta los pares de texto y fondo que cumplen el contraste, para que nadie los combine al azar.
  • Si registras una variable con @property y le das un tipo color, puedes animarla y el navegador la valida, lo que evita valores incorrectos.
@property --color-resalte {
  syntax: "<color>";
  inherits: true;
  initial-value: oklch(70% 0.15 90);
}

Contraste y accesibilidad

El color nunca es solo decoración. Una parte de tu público tiene baja visión, daltonismo, usa la pantalla bajo luz solar intensa o dispone de un monitor de baja calidad. Elegir bien los colores es una cuestión de usabilidad y también, en muchos países, una obligación legal.

Las pautas de accesibilidad del contenido web, conocidas como WCAG, definen el contraste mediante una relación entre la luminancia relativa del texto y la del fondo. Esa relación va de 1:1, sin contraste, a 21:1, que es el negro sobre blanco. La relación de contraste mínima para el nivel AA es de 4.5:1 para texto normal y de 3:1 para texto grande y para componentes de interfaz como bordes de campos y iconos. El nivel AAA, más exigente, pide 7:1 para texto normal.

Las cifras anteriores sirven como referencia práctica:

  • Texto de cuerpo sobre fondo liso: busca al menos 4.5:1.
  • Títulos grandes y negritas de tamaño elevado: 3:1 como mínimo.
  • Bordes de campos de formulario, iconos funcionales e indicadores de foco: 3:1 contra los colores adyacentes.
  • Texto decorativo o texto de un elemento deshabilitado queda exento, aunque conviene que siga siendo distinguible.

Existe además un método de cálculo alternativo, llamado APCA, que forma parte de los borradores de la siguiente generación de las pautas. Tiene en cuenta que el contraste percibido depende de la polaridad, del tamaño y del peso de la letra. Por ahora, la conformidad legal se mide con la relación de WCAG 2, así que utiliza esa como referencia oficial y toma APCA como información complementaria.

Cómo apoyarte en OKLCH para cumplir el contraste

Como la luminosidad de OKLCH es perceptual, puedes definir una escala de grises o de colores en pasos regulares de L y razonar sobre qué pares funcionan. Una pauta orientativa: una diferencia de luminosidad de unos 40 a 50 puntos porcentuales entre texto y fondo suele acercarse al 4.5:1, aunque no sustituye a la medición. Mide siempre con una herramienta; las de las propias DevTools de los navegadores muestran la relación calculada y señalan si cumple AA o AAA.

También puedes automatizar la elección del color del texto sobre un fondo variable. La sintaxis relativa permite una aproximación sencilla: si la luminosidad del fondo es alta, el texto es oscuro; si es baja, es claro.

.chip {
  --fondo: oklch(70% 0.15 200);
  background-color: var(--fondo);
  /* umbral de luminosidad: por encima de 0.62 usa texto oscuro */
  color: oklch(from var(--fondo) clamp(0, (0.62 - l) * 1000, 1) 0 0);
}

La fórmula usa una resta multiplicada por un número grande y la limita entre 0 y 1, lo que simula un interruptor: devuelve 0, texto negro, cuando la luminosidad supera el umbral, y 1, texto blanco, en caso contrario. Es un truco elegante, pero requiere soporte de color relativo; si lo usas, añade antes una declaración de color convencional como reserva y comprueba con una herramienta de contraste los extremos de tus colores.

No dependas solo del color

El contraste es una parte. La otra es no transmitir información únicamente mediante el color. Un campo con error marcado solo con un borde rojo es invisible para una persona con deficiencia en la percepción del rojo. Añade siempre un segundo canal: un icono, un texto de ayuda o un cambio de forma.

.campo[aria-invalid="true"] {
  border: 2px solid var(--color-peligro);
  background-image: url("icono-error.svg");
}

.campo__ayuda--error::before {
  content: "Error: ";
  font-weight: 700;
}

Otras preferencias del usuario que puedes respetar con consultas de medios:

@media (prefers-contrast: more) {
  :root {
    --color-texto: oklch(10% 0 0);
    --color-fondo: oklch(100% 0 0);
  }
}

@media (forced-colors: active) {
  .boton {
    border: 2px solid ButtonText;
  }
}

En el modo de colores forzados, típico de Windows en alto contraste, el navegador sustituye tus colores por los del sistema. Por eso no conviene transmitir significados importantes con fondos que van a desaparecer; los bordes y los contornos suelen sobrevivir mejor.

Errores comunes y cómo evitarlos

Después de revisar la teoría, estos son los fallos que aparecen una y otra vez en proyectos reales.

  1. Olvidar la propiedad. Escribir un valor de color suelto dentro de una regla no hace nada. Siempre debe existir una propiedad como color, background-color o border-color.
  2. Confundir opacidad y alfa. Atenuar un contenedor con opacity arrastra el texto interior. Si solo quieres un fondo translúcido, usa alfa.
  3. Alfa fuera de rango. Un valor mayor que 1 o menor que 0 se limita al rango válido. No produce un error, solo un resultado distinto del esperado.
  4. Mezclar sintaxis antigua y moderna en la misma función. No escribas una coma en unos argumentos y una barra en otros. Elige una forma y sé coherente.
  5. Asumir que HSL es perceptual. Dos colores con la misma L en HSL no tienen el mismo brillo. Para paletas fiables, usa OKLCH.
  6. Pasarse de croma. En OKLCH, un croma demasiado alto para una luminosidad y un tono dados queda fuera de gama y el navegador lo recorta, a veces con cambios de tono. Prueba el resultado en pantalla.
  7. No dar valores de reserva. Si usas funciones recientes, escribe antes una declaración compatible. Una declaración inválida se ignora, pero la anterior sigue vigente.
  8. Medir el contraste con el color final equivocado. Cuando el fondo tiene alfa, el contraste depende de lo que haya detrás. Calcula con el color compuesto real.
  9. Duplicar valores. Repetir el mismo hexadecimal en veinte reglas hace imposible un rediseño. Centraliza en variables.
  10. Nombrar variables por su apariencia. Es la causa más común de paletas que nadie quiere tocar.

Depuración rápida

Las herramientas de desarrollo del navegador son tus mejores aliadas. En el panel de estilos, al hacer clic sobre la muestra de un color puedes cambiar entre formatos y ver el valor equivalente en otros espacios. El selector de color suele mostrar además la relación de contraste y una línea que indica el umbral de AA y AAA, y puedes arrastrar el color hasta que la línea quede satisfecha.

Si un color no se aplica, comprueba esta lista:

  • ¿Aparece tachado en el panel de estilos? Entonces otra regla con mayor especificidad lo ha sobrescrito.
  • ¿Aparece con una advertencia de valor no válido? Probablemente hay una errata o una función que ese navegador no reconoce.
  • ¿Depende de una variable? Verifica que la variable existe en ese ámbito; si no, la declaración queda inválida en tiempo de cálculo y la propiedad vuelve a su valor heredado o inicial.

Ejemplo completo: un sistema de botones con una sola variable de marca

Para unir todas las ideas, construyamos un pequeño sistema de botones. La estructura de archivos es mínima:

proyecto/
├── index.html
└── estilos/
    ├── tokens.css
    └── botones.css

El archivo de tokens define la marca y los colores derivados:

/* estilos/tokens.css */
:root {
  color-scheme: light dark;

  --tono-marca: 255;
  --marca: oklch(56% 0.2 var(--tono-marca));

  --superficie: light-dark(oklch(98% 0.004 255), oklch(21% 0.02 255));
  --texto: light-dark(oklch(24% 0.02 255), oklch(93% 0.01 255));

  --accion: var(--marca);
  --accion-hover: color-mix(in oklch, var(--marca), black 18%);
  --accion-suave: color-mix(in oklch, var(--marca) 14%, transparent);
  --accion-texto: oklch(98% 0.01 255);

  --peligro: oklch(52% 0.22 27);
  --peligro-hover: color-mix(in oklch, var(--peligro), black 18%);
}

El archivo de botones consume solo variables semánticas:

/* estilos/botones.css */
.btn {
  display: inline-flex;
  align-items: center;
  padding: 0.6rem 1.1rem;
  border: 2px solid transparent;
  border-radius: 0.5rem;
  font: inherit;
  font-weight: 600;
  cursor: pointer;
  background-color: var(--accion);
  color: var(--accion-texto);
}

.btn:hover {
  background-color: var(--accion-hover);
}

.btn:focus-visible {
  outline: 3px solid var(--accion);
  outline-offset: 3px;
}

.btn--suave {
  background-color: var(--accion-suave);
  color: var(--accion);
  border-color: var(--accion);
}

.btn--peligro {
  background-color: var(--peligro);
}

.btn--peligro:hover {
  background-color: var(--peligro-hover);
}

.btn:disabled {
  background-color: color-mix(in oklch, var(--accion), gray 65%);
  cursor: not-allowed;
}

Y el HTML que los usa:

<link rel="stylesheet" href="estilos/tokens.css">
<link rel="stylesheet" href="estilos/botones.css">

<button class="btn">Guardar</button>
<button class="btn btn--suave">Cancelar</button>
<button class="btn btn--peligro">Eliminar</button>
<button class="btn" disabled>Enviar</button>

Si hoy decides que la marca debe ser verde, cambias un número en --tono-marca y todo el sistema se recalcula: el estado de hover, el fondo suave, el borde y el anillo de foco. Con colores escritos a mano en hexadecimal habrías tenido que editar cada valor y repetir las comprobaciones de contraste una por una. Aun así, tras cambiar el tono debes revisar el contraste del texto sobre el botón, porque aunque OKLCH mantiene la luminosidad estable, un cambio de tono puede alterar el croma máximo disponible y obligarte a ajustar el valor.

Este ejemplo muestra también el principio de la defensa en capas. Los botones no conocen ningún color concreto: solo conocen significados como acción, peligro y superficie. Eso los hace reutilizables, y la comprobación de accesibilidad se concentra en los pocos pares de variables que realmente se combinan.

Compatibilidad, rendimiento y estrategia de adopción

Una pregunta razonable es cuánto de todo esto puedes usar hoy sin miedo. La respuesta depende de tu público, pero hay una estrategia sencilla de tres niveles.

El primer nivel es el básico y seguro: hexadecimal, rgb(), hsl() y variables CSS. Funciona en cualquier navegador actual y en casi todos los antiguos que sigan en uso.

El segundo nivel es el moderno y estable: la sintaxis con espacios y barra, oklch() y color-mix() con dos colores. Cuentan con soporte en los motores principales y puedes usarlos con un valor de reserva sencillo cuando necesites cubrir versiones anteriores.

El tercer nivel es el reciente: el color relativo, light-dark() y la mezcla de tres o más colores. Úsalos tras comprobar la tabla de compatibilidad más reciente y con reservas bien definidas.

Un patrón de reserva eficaz usa la propia cascada:

.alerta {
  background-color: #1d6fe0;                 /* reserva clásica */
  background-color: oklch(56% 0.2 255);      /* moderno si se entiende */
}

Respecto al rendimiento, las funciones de color son baratas. Calcular un color-mix() o convertir un valor oklch() a la gama de la pantalla es trabajo trivial para el navegador comparado con el diseño, la pintura o el script. Lo que sí merece atención es la cantidad de repintados: animar un color de fondo obliga a repintar, mientras que animar la opacidad o una transformación suele resolverse en la composición. Si animas colores, hazlo en elementos pequeños y evita fondos a pantalla completa en dispositivos modestos.

Cuando animas entre dos colores, el espacio de interpolación también cambia el resultado. Puedes indicarlo en los degradados para obtener transiciones más naturales que las de sRGB, que tienden a producir zonas grises en el centro:

.cabecera {
  background-image: linear-gradient(in oklch to right, oklch(65% 0.22 20), oklch(65% 0.2 260));
}

Comparado con el mismo degradado calculado en sRGB, el resultado en OKLCH mantiene la viveza a lo largo de todo el recorrido. Si el tramo pasa por tonos inesperados, el modificador longer hue o shorter hue te deja decidir hacia qué lado gira el tono.

Una pequeña lista de comprobación antes de publicar

Antes de dar por cerrado un diseño, repasa estos puntos. Son rápidos y evitan los problemas más típicos.

  • Todos los colores de texto cumplen al menos 4.5:1 contra su fondo real, y los grandes 3:1.
  • Los bordes de campos, iconos útiles y anillos de foco alcanzan 3:1.
  • Ninguna información depende exclusivamente del color.
  • Hay valores de reserva para las funciones recientes.
  • Los colores se definen una sola vez, en variables, con nombres de función.
  • El tema oscuro se ha comprobado por separado y no es una simple inversión.
  • Has probado con el modo de contraste alto y con una simulación de daltonismo de las DevTools.
  • Las animaciones de color son discretas y respetan prefers-reduced-motion cuando son llamativas.

Si quieres situar todo esto en un recorrido más amplio, la hoja de ruta práctica para dominar CSS de principiante a experto ayuda a decidir qué estudiar a continuación, desde la cascada y la especificidad hasta el diseño con rejillas y las capas.

Conclusiones

El color en CSS ha pasado de ser una lista de nombres y números a un pequeño lenguaje de diseño con espacios perceptuales, mezcla en el navegador y derivación de paletas. Las formas clásicas siguen siendo válidas, pero la combinación de la sintaxis con espacios y barra, oklch(), color-mix() y variables ofrece un código más corto, más coherente y más fácil de mantener.

Conviene retener unas pocas ideas. El alfa de un color y la propiedad opacity no son lo mismo, y confundirlas produce textos ilegibles. El valor alfa admite cualquier número entre 0 y 1, y la sintaxis permite espacios con libertad. HSL es cómodo, pero su luminosidad no es perceptual, mientras que OKLCH sí lo es y facilita razonar sobre el contraste. color-mix() cuenta con soporte amplio desde 2023 en los motores principales, y las funciones más recientes, como el color relativo o la mezcla de tres colores, deben usarse con reservas y tras revisar la compatibilidad vigente.

Por último, recuerda que el color debe servir a las personas. Mide el contraste, no dependas solo del tono para comunicar estados y respeta las preferencias del sistema. Si organizas tu paleta en primitivos y tokens semánticos, cualquier cambio de marca, de tema o de accesibilidad se convierte en una edición de unas pocas líneas y no en una búsqueda y sustitución por todo el proyecto.