Por qué las tipografías pesan más de lo que crees
Cuando se habla de rendimiento web, casi todas las conversaciones giran en torno a las imágenes, el JavaScript y las peticiones a la API. Las tipografías pasan desapercibidas, y sin embargo son uno de los recursos que más afectan a la sensación de velocidad. Un archivo de fuente es un recurso que bloquea el renderizado del texto: hasta que el navegador sabe qué glifos dibujar, no puede pintar con fidelidad el contenido más importante de la página, que casi siempre es el titular y el primer párrafo.
El problema tiene dos caras. La primera es el peso: una familia completa con cuatro o cinco variantes, cada una con miles de glifos para alfabetos que nunca usarás, puede superar con facilidad los 300 KB. La segunda es el comportamiento visual: según cómo declares la fuente, el usuario verá un hueco en blanco, un parpadeo de texto que cambia de aspecto o un salto del diseño cuando por fin llega el archivo. Las tres métricas que se miran en Core Web Vitals se ven afectadas: el Largest Contentful Paint (si el elemento más grande es texto), el Cumulative Layout Shift (por los saltos al cambiar de fuente) y, en menor medida, la interactividad.
En este tutorial vas a recorrer un flujo completo y actual para servir tipografías sin sacrificar rendimiento. Verás qué formatos usar hoy, cómo escribir una regla @font-face correcta, qué hace realmente font-display, cuándo conviene precargar y cuándo es contraproducente, cómo recortar los glifos (subsetting), qué aportan las fuentes variables y cómo reducir el salto de diseño ajustando las métricas de la fuente de respaldo. También encontrarás una lista de errores frecuentes y una checklist final para auditar cualquier proyecto.
Todo lo que se cuenta aquí es independiente del framework. Los ejemplos usan HTML y CSS planos, y al final verás cómo encajan en un proyecto con herramientas modernas. Si trabajas con Next.js, te vendrá bien complementar esta lectura con la guía de optimización avanzada de páginas web con Next.js, Sass y CSS Modules, donde se aborda el rendimiento desde el lado del framework.
Qué ha cambiado desde los viejos tiempos de las fuentes web
Hace unos años era habitual declarar cuatro formatos en cada regla: EOT para Internet Explorer antiguo, TTF u OTF para navegadores móviles viejos, WOFF para la mayoría y SVG para iOS antiguos. Esa cadena de respaldo ya no tiene sentido. Hoy el panorama es mucho más sencillo:
- WOFF2 es compatible con todos los navegadores actuales de escritorio y móvil. Comprime mejor que WOFF porque usa Brotli, con un ahorro típico de alrededor de un 30 % frente a WOFF.
- WOFF solo se mantiene como respaldo si tu analítica demuestra que aún recibes tráfico de navegadores que no entienden WOFF2, algo cada vez más raro.
- EOT y SVG son historia. Si ves referencias en CSS heredado, puedes eliminarlas.
- TTF y OTF se usan como archivos de origen para tu pipeline, pero no deberías servirlos al usuario final: pesan bastante más.
La recomendación práctica actual es directa: sirve solo WOFF2. Una única línea en src con format("woff2") cubre prácticamente a todo el mundo, reduce el tamaño del CSS y simplifica el mantenimiento.
Otro cambio importante es la práctica de autoalojar las fuentes. Antes se recomendaba cargar desde un proveedor externo porque la caché compartida entre sitios ahorraba descargas. Ese argumento desapareció: los navegadores modernos particionan la caché por sitio, de modo que una fuente descargada desde otro dominio no se reutiliza entre sitios distintos. Cargarla desde un tercero añade una resolución DNS, una conexión TLS y una dependencia externa, con costes de privacidad incluidos. Servir los archivos desde tu propio dominio, o desde tu CDN, suele ser más rápido y predecible. Si necesitas distribuir recursos desde una red de entrega, repasa cómo importar JavaScript y CSS desde un CDN público en proyectos web para entender sus ventajas y sus riesgos.
Anatomía de una regla @font-face bien escrita
Todo comienza en CSS. Una declaración mínima pero correcta se ve así:
@font-face {
font-family: "Lumina";
src: url("/fonts/lumina-regular.woff2") format("woff2");
font-weight: 400;
font-style: normal;
font-display: swap;
}
@font-face {
font-family: "Lumina";
src: url("/fonts/lumina-bold.woff2") format("woff2");
font-weight: 700;
font-style: normal;
font-display: swap;
}
Merece la pena detenerse en cada descriptor.
font-family es el nombre que usarás en el resto de tu CSS. Puedes elegir cualquier cadena, pero conviene que sea estable y que coincida con la familia real para evitar confusiones. Si dos reglas comparten nombre y se diferencian por font-weight y font-style, el navegador las trata como una misma familia con varias variantes y elige la apropiada para cada elemento.
src es una lista ordenada. El navegador recorre las entradas y usa la primera que pueda interpretar. El hint format("woff2") evita que se descargue un archivo cuyo formato ni siquiera soporta. Con un solo formato, la lista es de una línea; si añades un respaldo, WOFF2 va primero.
font-weight y font-style no son decorativos: indican al navegador qué variante cubre cada archivo. Si los omites, el valor por defecto es normal, y el navegador podría sintetizar negritas o cursivas falsas que se ven mal. Declara siempre el peso real.
También puedes usar local() dentro de src para aprovechar una copia instalada en el sistema del usuario. Suena atractivo, pero tiene trampas: un usuario puede tener una versión distinta o modificada de la fuente con el mismo nombre, y el resultado visual diferiría del que diseñaste. Para fuentes propias o poco comunes, es mejor omitirlo; para tipografías muy extendidas del sistema, puede ahorrar una descarga.
Uso en la hoja de estilos
Una vez declaradas, las fuentes se usan con font-family y una pila de respaldo coherente:
:root {
--fuente-texto: "Lumina", system-ui, -apple-system, "Segoe UI", sans-serif;
}
body {
font-family: var(--fuente-texto);
font-weight: 400;
line-height: 1.6;
}
h1,
h2 {
font-weight: 700;
}
La pila de respaldo no es un adorno. Durante la carga, el navegador puede mostrar la siguiente fuente de la lista, y elegirla bien reduce el cambio visual cuando llega la definitiva. Más adelante verás cómo afinarla con precisión.
font-display: elige el comportamiento mientras carga
El descriptor font-display define qué hace el navegador entre el momento en que necesita una fuente y el momento en que está disponible. Cada valor divide ese intervalo en tres periodos: bloqueo (texto invisible), intercambio (se muestra la fuente de respaldo y se cambia al llegar la definitiva) y fallo (se abandona la fuente web).
Los valores disponibles son:
auto: deja la decisión al navegador, que normalmente se comporta comoblock.block: periodo de bloqueo largo; el texto permanece invisible hasta que llega la fuente, con intercambio posterior ilimitado.swap: periodo de bloqueo casi nulo e intercambio ilimitado. El texto aparece enseguida con la fuente de respaldo y se sustituye cuando llega la web.fallback: bloqueo muy corto y un intercambio acotado a unos pocos segundos; si la fuente tarda demasiado, se queda la de respaldo para esa visita.optional: bloqueo muy corto y prácticamente sin intercambio; el navegador decide si usar la fuente según las condiciones de la red, y si no está lista de inmediato se queda con la de respaldo.
En la práctica, la elección se reduce a una pregunta: ¿qué es peor para tu página, mostrar un texto con la fuente equivocada un instante o provocar un salto visual?
Para la mayoría de sitios de contenido, como blogs, documentación o tiendas, swap es una buena opción por defecto: el contenido se lee de inmediato, y el salto se mitiga con las técnicas que verás más adelante. Para titulares de marca en los que un cambio abrupto resulta molesto, fallback ofrece un término medio. Y optional es la elección más conservadora respecto al layout: la primera visita puede ver la fuente de respaldo, pero las siguientes ya tendrán la web en caché y no habrá ningún salto. Funciona especialmente bien combinada con una precarga, porque si la fuente llega a tiempo, se usa sin cambios.
Una curiosidad útil: el comportamiento sin font-display ha variado entre navegadores. Algunos ocultaban el texto un máximo de unos tres segundos antes de recurrir a la alternativa, y otros lo mantenían oculto hasta que llegaba la fuente. Declarar el valor de forma explícita elimina esa disparidad y hace tu página predecible.
Un detalle más: font-display va en la regla @font-face, no en los elementos que usan la fuente. Si cargas desde un proveedor que genera el CSS, comprueba que la URL incluya el parámetro correspondiente para que ese valor aparezca en las reglas generadas.
Precarga: acelerar sin desperdiciar ancho de banda
Por defecto, el navegador descubre una fuente tarde. Primero descarga el HTML, después el CSS, luego construye el árbol de renderizado, y solo cuando detecta que algún texto visible necesita esa familia, lanza la petición. Esa cascada retrasa el momento en que el texto final aparece. La precarga rompe la cadena: le dices al navegador, desde el HTML, que pronto necesitará ese archivo.
<head>
<link
rel="preload"
href="/fonts/lumina-regular.woff2"
as="font"
type="font/woff2"
crossorigin
/>
<link rel="stylesheet" href="/css/estilos.css" />
</head>
Hay cuatro puntos en los que se tropieza con frecuencia:
- El atributo
crossorigines obligatorio incluso cuando la fuente se sirve desde tu mismo dominio. Las fuentes se piden en modo CORS; si la precarga no lo indica, el navegador la descarta como no coincidente y pide el archivo otra vez, con lo que pagas la descarga doble. - La URL debe coincidir exactamente con la que aparece en
@font-face. Una diferencia en la ruta, un parámetro de versión o una mayúscula basta para que no se reutilice. - El
typeha de ser correcto. Para WOFF2 se usafont/woff2. Si precargas un respaldo en WOFF, el tipo esfont/woff. Copiar y pegar el mismo tipo en ambos enlaces es un error clásico. - Precarga solo lo imprescindible. Cada precarga compite con otros recursos críticos como el CSS y las imágenes principales. Reserva este mecanismo para la variante que se usa en el contenido visible al cargar, normalmente la regular y, como mucho, la negrita del titular.
Existe además una advertencia que a menudo se pasa por alto: la precarga ignora unicode-range. El navegador descarga el archivo que le indicas sin evaluar si la página contiene caracteres de ese rango. Si partes tu fuente en varios subconjuntos (latín, cirílico, griego) y precargas todos, descargarás archivos que no se usarán. Precarga únicamente el subconjunto que vas a necesitar con seguridad, que en un sitio en español suele ser el latino.
Alternativas: preconnect y prefetch
Si las fuentes viven en otro origen, preconnect adelanta la resolución DNS, la conexión TCP y el handshake TLS, sin descargar nada todavía. Es más fácil de mantener que la precarga, porque no obliga a conocer las URLs exactas, pero ofrece menos beneficio. Con fuentes autoalojadas en tu propio dominio, no hace falta: la conexión ya está abierta cuando llega el HTML.
prefetch, por su parte, sirve para recursos que se necesitarán en una navegación futura. Tiene prioridad baja y no es la herramienta adecuada para la tipografía de la página actual.
Subsetting: enviar solo los glifos que necesitas
Una fuente profesional puede contener miles de glifos: alfabetos extendidos, símbolos matemáticos, ligaduras, formas alternativas. Un blog en español usa una fracción pequeña. El subsetting consiste en generar una copia del archivo que contenga únicamente los caracteres que realmente necesitas, y puede reducir el peso de forma drástica.
Hay dos mecanismos complementarios.
Partir la fuente con unicode-range
El descriptor unicode-range indica a qué caracteres se aplica cada regla. Si divides la familia en varios archivos por alfabetos, el navegador descargará solo los que correspondan a los caracteres presentes en la página:
/* Latín básico y signos habituales en español */
@font-face {
font-family: "Lumina";
src: url("/fonts/lumina-latin.woff2") format("woff2");
font-display: swap;
unicode-range: U+0020-007E, U+00A0-00FF, U+20AC, U+2013-2014, U+2018-201D;
}
/* Latín extendido, para nombres propios de otros idiomas */
@font-face {
font-family: "Lumina";
src: url("/fonts/lumina-latin-ext.woff2") format("woff2");
font-display: swap;
unicode-range: U+0100-024F, U+1E00-1EFF;
}
Con esta división, una página en español descarga solo el primer archivo; el segundo solo se pide si aparece, por ejemplo, un nombre con caracteres de latín extendido. Es el enfoque que usan los grandes proveedores de fuentes: sirven decenas de fragmentos por familia, y tu navegador descarga solo los que necesita.
Una aclaración importante sobre unicode-range: no recorta el contenido de un archivo, solo decide cuándo se descarga. Si apuntas a un archivo con la fuente completa, tendrás el mismo peso, así que el rango solo ahorra bytes si has generado archivos separados.
Generar el subconjunto
Para recortar de verdad necesitas una herramienta. La más extendida en línea de comandos es pyftsubset, incluida en el paquete Python fonttools. Convierte a WOFF2 y limita glifos en un solo paso (para WOFF2 necesita además el módulo de compresión Brotli):
pip install fonttools brotli
pyftsubset Lumina-Regular.ttf \
--unicodes="U+0020-007E,U+00A0-00FF,U+20AC,U+2013-2014,U+2018-201D" \
--flavor=woff2 \
--layout-features="kern,liga,calt" \
--output-file=lumina-latin.woff2
El parámetro --layout-features es relevante: controla qué características tipográficas se conservan. Si no necesitas ligaduras o números tabulares, eliminarlos reduce aún más el tamaño; si los usas, indícalos explícitamente para no perderlos. Tras ejecutar el comando, compara tamaños:
ls -lh Lumina-Regular.ttf lumina-latin.woff2
-rw-r--r-- 1 usuario usuario 312K Lumina-Regular.ttf
-rw-r--r-- 1 usuario usuario 18K lumina-latin.woff2
La salida anterior es solo ilustrativa: el ahorro real depende de cada fuente, pero pasar de cientos de kilobytes a decenas es habitual cuando se parte de un archivo con soporte multilingüe.
Una advertencia sobre las licencias: no todas las tipografías permiten modificar el archivo. Antes de recortar o convertir una fuente comercial, revisa los términos. Las fuentes con licencia abierta, como las que se publican bajo la licencia OFL, lo permiten, normalmente con la condición de no usar el nombre reservado si distribuyes una versión modificada.
Otros paquetes que facilitan el trabajo son los de Fontsource, que distribuyen familias abiertas ya fragmentadas por alfabeto para instalarlas con el gestor de paquetes, y los generadores en línea que producen el CSS junto con los archivos. Verifica siempre que la herramienta que elijas admita fuentes variables, porque algunas más antiguas no lo hacen.
Fuentes variables: una familia en un solo archivo
Una fuente variable contiene un espacio de diseño continuo en lugar de instancias fijas. En vez de un archivo para cada peso, un único archivo permite cualquier valor entre un mínimo y un máximo en uno o varios ejes. Los ejes registrados más comunes son peso (wght), anchura (wdth), inclinación (slnt), cursiva (ital) y tamaño óptico (opsz). Además, los diseñadores pueden definir ejes personalizados.
La declaración usa rangos en lugar de valores únicos:
@font-face {
font-family: "Lumina Variable";
src: url("/fonts/lumina-variable.woff2") format("woff2");
font-weight: 100 900;
font-stretch: 75% 125%;
font-style: normal;
font-display: swap;
}
body {
font-family: "Lumina Variable", system-ui, sans-serif;
font-weight: 430;
}
.destacado {
font-weight: 650;
font-variation-settings: "opsz" 24;
}
El navegador interpola entre los extremos, de modo que puedes usar un peso de 430 o de 650 sin cargar nada más. La propiedad font-variation-settings permite manipular ejes directamente, aunque se recomienda usar las propiedades CSS de alto nivel (font-weight, font-stretch, font-optical-sizing) siempre que existan, porque respetan mejor las cascadas y las preferencias del usuario.
Cuándo compensan
Las fuentes variables brillan cuando usas tres o más variantes de la misma familia. Un solo archivo variable suele pesar menos que la suma de los archivos estáticos equivalentes, y reduce el número de peticiones. Si solo necesitas la regular y la negrita, una fuente variable completa puede incluso pesar más que dos archivos estáticos recortados. La regla práctica: cuenta las variantes que usarás y compara el peso total de ambas opciones antes de decidir.
También hay que valorar si te interesa la flexibilidad tipográfica. Poder ajustar el peso con precisión para modo oscuro, aligerar el texto en pantallas pequeñas o animar la anchura de un titular son posibilidades que solo ofrece este formato.
Detalles técnicos
Algunos puntos que conviene recordar:
- El soporte en navegadores actuales es amplio; no necesitas un respaldo estático para la mayoría de públicos.
- Puedes subdividir una fuente variable con
unicode-rangeigual que una estática, y reducir los ejes que no uses con la herramienta de subsetting para que el archivo pese menos. Confonttoolsexiste una utilidad de instanciación parcial que permite fijar o limitar ejes. - La precarga de fuentes variables funciona igual que la de cualquier archivo WOFF2, con
crossoriginincluido. Los problemas que existieron al principio con ciertos navegadores ya no son relevantes, aunque sigue siendo buena práctica verificar en tu caso con las herramientas de desarrollo.
Evitar el salto de diseño con métricas de respaldo
Aunque uses swap, el cambio entre la fuente de respaldo y la definitiva puede mover el texto, porque cada tipografía tiene una anchura media de carácter y unas proporciones verticales distintas. Si el texto ocupa más líneas, todo lo que hay debajo se desplaza, y el Cumulative Layout Shift empeora.
La solución moderna es ajustar la fuente de respaldo para que ocupe el mismo espacio que la definitiva. CSS ofrece descriptores específicos en @font-face para este propósito: size-adjust, ascent-override, descent-override y line-gap-override. Se crea una regla adicional que apunta a una fuente local y le aplica correcciones:
@font-face {
font-family: "Lumina Ajustada";
src: local("Arial");
size-adjust: 104%;
ascent-override: 92%;
descent-override: 24%;
line-gap-override: 0%;
}
body {
font-family: "Lumina", "Lumina Ajustada", sans-serif;
}
Con esa definición, mientras carga “Lumina” el navegador muestra Arial escalada y alineada para parecerse a ella. Cuando llega la definitiva, el cambio apenas se nota. Los porcentajes se calculan a partir de las métricas de ambas fuentes, y hay herramientas que los generan automáticamente a partir de los archivos. Algunos frameworks aplican este cálculo de forma automática al cargar las fuentes mediante sus utilidades integradas, lo que ahorra el trabajo manual.
Este enfoque combina muy bien con font-display: swap: obtienes visibilidad inmediata del texto y un cambio casi imperceptible. Es, hoy por hoy, la técnica con mejor equilibrio entre rapidez y estabilidad visual.
Uso en proyectos con herramientas modernas
En un proyecto real, rara vez escribes todo a mano. Los empaquetadores y frameworks ofrecen ayudas que automatizan buena parte de lo anterior.
Con Vite, Webpack o similares, puedes importar el CSS con las reglas @font-face y dejar que el empaquetador procese las URLs: genera nombres con hash para cachear de forma agresiva y copia los archivos a la carpeta de salida. Un diseño de directorios típico sería:
proyecto/
├── public/
│ └── fonts/
│ ├── lumina-latin.woff2
│ ├── lumina-latin-ext.woff2
│ └── lumina-variable.woff2
├── src/
│ ├── css/
│ │ ├── fuentes.css
│ │ └── estilos.css
│ └── index.html
└── package.json
Mantener las reglas @font-face en un archivo propio (fuentes.css) facilita revisarlas y evita que se pierdan entre otros estilos.
Si usas Tailwind, puedes registrar la familia en la configuración del tema y utilizarla con las clases utilitarias de siempre. En la versión actual del framework la configuración se hace directamente en CSS, de modo que tus reglas @font-face y la definición de la variable de tema conviven en la misma hoja. Para profundizar en esa forma de trabajar, te será útil aprender Tailwind CSS v4 como framework utility-first para desarrollo moderno.
@import "tailwindcss";
@font-face {
font-family: "Lumina Variable";
src: url("/fonts/lumina-variable.woff2") format("woff2");
font-weight: 100 900;
font-display: swap;
}
@theme {
--font-sans: "Lumina Variable", system-ui, sans-serif;
}
Con esa configuración, la clase font-sans aplicará la tipografía en todo el proyecto, y las clases de peso (font-medium, font-bold) aprovecharán el rango variable sin archivos adicionales.
Cabeceras de caché y servidor
Las fuentes cambian muy rara vez, así que pueden cachearse durante mucho tiempo. Usa nombres de archivo con hash o versión y una cabecera Cache-Control con una duración larga y el indicador immutable. Así, las visitas recurrentes no vuelven a descargar nada. Un ejemplo para Nginx:
location /fonts/ {
add_header Cache-Control "public, max-age=31536000, immutable";
add_header Access-Control-Allow-Origin "*";
types { font/woff2 woff2; }
}
Si sirves las fuentes desde un subdominio o un CDN distinto del de la página, necesitarás la cabecera CORS, porque las fuentes se piden en modo CORS. Sin ella, el navegador las bloqueará y verás errores en la consola. Con el mismo origen no hace falta, pero la precarga sigue requiriendo crossorigin.
Además, asegúrate de que el servidor comprime lo necesario. WOFF2 ya viene comprimido con Brotli internamente, así que aplicar otra capa de compresión HTTP no aporta nada y consume CPU. Es un archivo que conviene excluir de esas reglas.
Medir antes y después
Optimizar sin medir es adivinar. Hay varias formas de comprobar el efecto de los cambios.
En la pestaña de red de las herramientas del navegador, filtra por tipo de fuente y revisa qué archivos se descargan, su tamaño y el momento en que empiezan. Si ves el mismo archivo dos veces, probablemente falta crossorigin en la precarga o la URL no coincide. Si ves archivos que no usas, tu unicode-range o tu subsetting necesita ajuste.
En la pestaña de rendimiento, una grabación con la red limitada a una conexión lenta muestra cuándo se pinta el primer texto y si se produce un cambio de diseño al llegar la fuente. Los desplazamientos aparecen marcados y puedes identificar qué elemento los provoca.
Lighthouse y las herramientas de laboratorio informan de las fuentes que bloquean el renderizado, del tiempo hasta el contenido principal y del CLS. Una auditoría específica avisa cuando el texto permanece invisible durante la carga, lo que indica que falta font-display.
Los datos de campo, es decir, las métricas de usuarios reales, obtenidas a partir del informe de experiencia de usuario de Chrome o con una librería de métricas web en tu propio sitio, reflejan mejor la realidad que cualquier prueba local, porque incluyen redes y dispositivos variados.
Una buena práctica es registrar los valores iniciales antes de tocar nada: peso total de fuentes, LCP, CLS y número de peticiones de tipografía. Tras cada cambio, repite la medida. Así sabrás qué técnica aporta más en tu caso concreto; en ocasiones, el subsetting da más resultado que la precarga, y otras veces ocurre al revés.
Errores frecuentes y cómo resolverlos
Aunque el tema parece sencillo, los mismos fallos se repiten en muchos proyectos.
Precargar sin crossorigin. Es el error número uno. Síntoma: en la pestaña de red aparece la fuente dos veces, y la consola muestra un aviso de que el recurso precargado no se usó en pocos segundos. Solución: añadir el atributo.
Precargar demasiadas fuentes. Cuando se precargan seis archivos, compiten con el CSS y las imágenes del primer pantallazo, y el resultado es peor que sin precarga. Limita la selección a una o dos variantes críticas.
Mezclar rutas relativas y absolutas. Si la precarga apunta a una ruta y @font-face a otra equivalente pero escrita distinto, el navegador las trata como recursos diferentes. Usa rutas absolutas desde la raíz en ambos sitios.
Olvidar el peso y el estilo reales. Declarar una fuente sin font-weight provoca negritas sintéticas. Verás letras ensanchadas artificialmente, sin la calidad del diseño original.
Cargar una familia completa para usar un solo peso. Si en tu diseño solo aparecen la regular y la negrita, no cargues cinco pesos “por si acaso”. Cada variante extra es peso inútil.
Servir TTF o OTF directamente. Son notablemente más pesados que WOFF2 y no tienen ventajas para el usuario final. Conviértelos.
Ignorar el tipo MIME. Si el servidor entrega el archivo con un tipo genérico, algunos navegadores o proxies pueden tratarlo mal. Configura el tipo correcto para la extensión.
Fuentes de iconos para todo. Cargar una fuente completa de iconos para mostrar tres símbolos es un derroche. Considera usar SVG en línea o un subconjunto de la fuente con solo los iconos necesarios.
No tener plan para fallos. Si la fuente no carga, tu diseño debe seguir siendo legible. Elige una pila de respaldo razonable, con la tipografía del sistema como último recurso, y prueba tu página con las fuentes bloqueadas.
Accesibilidad y preferencias del usuario
El rendimiento no es lo único que importa. Una tipografía bien elegida y bien cargada también afecta a la accesibilidad.
Respeta el tamaño de fuente del usuario: define tamaños en rem o em en lugar de píxeles fijos para que el texto escale con la configuración del navegador. Cuida el contraste y el interlineado, y comprueba que la fuente de respaldo mantenga una legibilidad similar a la web. En personas con dislexia u otras necesidades, la posibilidad de sustituir la tipografía por una propia es importante: evita bloquear esa opción con trucos de diseño.
Para el movimiento, si animas ejes de una fuente variable (por ejemplo, el peso al pasar el ratón), respeta la preferencia de reducir animaciones:
.enlace {
transition: font-weight 0.2s ease;
}
.enlace:hover {
font-weight: 700;
}
@media (prefers-reduced-motion: reduce) {
.enlace {
transition: none;
}
}
Por último, recuerda que el cambio de anchura de un texto al variar su peso puede desplazar el contenido adyacente. Si animas el peso, hazlo en elementos donde el reajuste no moleste, o reserva el espacio con un ancho mínimo.
Privacidad y cumplimiento normativo
Cargar tipografías desde un servicio externo implica que la dirección IP de cada visitante llega a un tercero. En Europa, algunos tribunales han considerado que esto puede incumplir la normativa de protección de datos si no existe una base legal adecuada. Autoalojar las fuentes elimina el problema de raíz: los archivos salen de tu infraestructura y no hay transferencia a terceros.
Esto es otro argumento a favor de la estrategia que se ha descrito: descarga los archivos con licencia abierta, conviértelos a WOFF2, recórtalos y sírvelos tú mismo. Además de la privacidad, ganas control sobre la caché, la compresión y las cabeceras, y eliminas un punto de fallo externo.
Un flujo de trabajo completo, de principio a fin
Para fijar ideas, este es un recorrido completo con una familia abierta hipotética.
- Elige las variantes que necesitas. Revisa el diseño y haz una lista: texto regular, cursiva ocasional, titulares en negrita. Si son tres o más y el diseñador quiere flexibilidad, valora una fuente variable.
- Consigue los archivos de origen con una licencia que permita el uso web y la modificación.
- Genera el subconjunto latino con
pyftsubset, usando los rangos de caracteres de tu idioma, y exporta a WOFF2. Si necesitas otros alfabetos, crea un archivo adicional por cada uno y decláralos conunicode-range. - Escribe las reglas
@font-faceconfont-displayexplícito, pesos reales ysrcde una sola línea. - Añade la fuente de respaldo ajustada con
size-adjusty las sobreescrituras verticales para reducir el salto de diseño. - Precarga solo la variante crítica con
crossoriginy el tipo correcto. - Configura el servidor: caché larga e inmutable, CORS si procede y tipo MIME adecuado.
- Mide. Compara peso, LCP y CLS con los valores iniciales y repite la prueba en una red lenta.
- Automatiza la comprobación en tu integración continua, de modo que un cambio que añada una fuente de más o rompa una ruta de precarga no pase desapercibido.
Para esa última parte, un script sencillo que falle si el peso total de las fuentes supera un presupuesto puede ser suficiente:
#!/bin/sh
LIMITE=122880 # 120 KB en bytes
TOTAL=$(cat public/fonts/*.woff2 | wc -c)
if [ "$TOTAL" -gt "$LIMITE" ]; then
echo "Presupuesto de fuentes superado: $TOTAL bytes"
exit 1
fi
echo "Fuentes dentro del presupuesto: $TOTAL bytes"
Un presupuesto explícito convierte la buena intención en una regla verificable, y evita que el peso crezca con el tiempo sin que nadie lo note.
Comparativa de estrategias según el tipo de sitio
No existe una única configuración correcta. Estas son recomendaciones razonables según el caso.
Blog o sitio de documentación. Prioriza la lectura inmediata. Usa una o dos variantes en WOFF2 autoalojado, font-display: swap, fuente de respaldo ajustada y precarga de la regular. El contenido es sobre todo texto, así que el LCP depende de que el primer párrafo se pinte rápido.
Tienda en línea. Aquí las imágenes de producto suelen ser el LCP, y las fuentes no deberían competir con ellas. Limita las precargas a una sola fuente y considera optional para tipografías decorativas que no aportan información.
Aplicación web con interfaz densa. Una fuente variable ayuda a obtener jerarquía visual con un solo archivo. Si la aplicación se usa de forma recurrente, la caché amortiza el coste inicial, y puedes permitirte swap sin preocuparte demasiado.
Sitio de marca con tipografía distintiva. Si la identidad depende de una fuente particular en el titular, puedes usar fallback para el titular y swap para el cuerpo, o precargar el archivo del titular y ajustar con precisión la fuente de respaldo para que la diferencia sea mínima.
Sitio multilingüe. El unicode-range es tu mejor aliado. Declara un fragmento por alfabeto y deja que el navegador descargue solo los que cada página necesite. Evita precargar subconjuntos que no se usan en todas las páginas.
Lista de comprobación final
Antes de dar por terminado el trabajo, repasa esta lista:
- Los archivos servidos son WOFF2, salvo justificación expresa de un respaldo.
- Las fuentes se alojan en tu dominio o CDN, no en un servicio de terceros sin necesidad.
- Cada regla
@font-facedeclarafont-family,srccon formato,font-weight,font-styleyfont-display. - Los archivos están recortados a los glifos necesarios y, en casos multilingües, divididos con
unicode-range. - Hay como máximo una o dos precargas, con
as="font", el tipo correcto ycrossorigin, y sus URLs coinciden con las del CSS. - La fuente de respaldo tiene métricas ajustadas para reducir el desplazamiento.
- Si usas tres o más variantes, se ha evaluado una fuente variable y se ha comparado el peso total.
- El servidor envía caché larga, tipo MIME correcto y CORS cuando corresponde.
- Se han medido el peso, el LCP y el CLS antes y después de los cambios.
- La página sigue siendo legible si la fuente web falla.
Conclusiones
Las tipografías web son un recurso pequeño en apariencia y decisivo en la práctica. Una configuración cuidadosa se resume en pocas ideas: sirve WOFF2 desde tu propio dominio, recorta los glifos que no necesitas, declara font-display de forma explícita, precarga únicamente lo crítico con crossorigin y ajusta la fuente de respaldo para que el cambio visual sea casi invisible. Las fuentes variables aportan un enorme valor cuando tu diseño usa varias variantes, pero conviene comparar pesos antes de adoptarlas por defecto.
Lo más importante es adoptar el hábito de medir. Cada proyecto tiene sus particularidades, y la combinación ideal de swap, optional, subsetting y precarga depende de tu contenido, de tu audiencia y de tu infraestructura. Con las herramientas actuales, conseguir una tipografía cuidada y a la vez rápida ya no exige trucos: basta con aplicar estas prácticas con criterio, automatizar las comprobaciones y revisar los resultados de forma periódica. Así tus usuarios leerán antes, el diseño permanecerá estable y tus métricas de rendimiento lo reflejarán.
