Por qué conviene aprender Sass hoy
Cualquiera que haya mantenido una hoja de estilos de más de mil líneas conoce el problema: el mismo color hexadecimal repetido en cuarenta sitios, selectores que se copian y se pegan con pequeñas variaciones, y un único archivo en el que nadie se atreve a tocar nada. Sass nació para resolver precisamente eso. Es un preprocesador: escribes en un lenguaje que extiende CSS con variables, anidamiento, módulos, mixins y funciones, y un compilador lo transforma en CSS plano que el navegador entiende sin ayuda.
Es cierto que CSS nativo ha avanzado mucho. Hoy existen propiedades personalizadas con var(), anidamiento nativo y funciones de color modernas. Aun así, Sass sigue siendo una herramienta muy presente en sistemas de diseño, librerías de componentes y frameworks. Muchos proyectos existentes lo usan, y cuando necesitas bucles, mapas de datos, funciones propias o una organización estricta en módulos, Sass ofrece cosas que el CSS del navegador no tiene.
En este tutorial construirás un pequeño proyecto desde cero con la implementación oficial actual, Dart Sass, que pertenece a la serie 1.x y es la única que recibe desarrollo activo. Verás la sintaxis SCSS, el sistema de módulos moderno basado en @use y @forward, y los patrones más útiles del día a día. También aprenderás qué prácticas antiguas debes evitar, como @import, la división con / o las funciones lighten() y darken() globales, porque están en proceso de eliminación y generan avisos al compilar.
Si todavía no dominas los fundamentos del lenguaje de estilos, conviene repasarlos antes con la hoja de ruta práctica para dominar CSS. Sass asume que ya sabes qué es un selector, una propiedad y una media query.
Dos sintaxis, un mismo compilador
Sass admite dos formatos de archivo. El primero es la sintaxis con sangrías, con extensión .sass, que elimina llaves y puntos y coma y delimita los bloques por indentación. El segundo es SCSS, con extensión .scss, que es un superconjunto de CSS: cualquier hoja CSS válida es automáticamente un archivo SCSS válido. Esa propiedad lo hace ideal para migrar de forma gradual, porque puedes renombrar un .css a .scss y ir añadiendo funciones poco a poco.
Compara el mismo fragmento en ambas formas. Primero SCSS:
.tarjeta {
padding: 1rem;
border: 1px solid #ddd;
.titulo {
font-weight: 700;
}
}
Y ahora la sintaxis con sangrías:
.tarjeta
padding: 1rem
border: 1px solid #ddd
.titulo
font-weight: 700
En este artículo usaremos SCSS porque es el formato dominante, el que emplean la mayoría de las librerías y el que se lee con más naturalidad si vienes de CSS. Todo lo que aprendas se traslada igual a la otra sintaxis, solo cambia la puntuación.
Instalar Dart Sass con npm
La forma más directa de obtener el compilador en un proyecto web es mediante npm. El paquete se llama sass y es la versión de Dart Sass compilada a JavaScript. Crea una carpeta de trabajo e instálalo como dependencia de desarrollo:
mkdir tienda-sass && cd tienda-sass
npm init -y
npm install --save-dev sass
Para comprobar que funciona, pide la versión desde el ejecutable local:
npx sass --version
La salida mostrará un número de la serie 1.x seguido del indicador de implementación, algo como 1.x.y compiled with dart2js. No necesitas fijarte en el valor exacto, pero sí conviene anotar la versión en el archivo package.json para que todo el equipo compile con la misma.
También existe la instalación global con npm install -g sass, y el compilador está disponible por otros canales como Homebrew, Chocolatey o un binario independiente. Para proyectos reales, la instalación local es preferible: evita diferencias entre máquinas y facilita la integración continua.
Una advertencia histórica: si ves tutoriales que mencionan node-sass o ruby-sass, ignóralos. Ambos están descontinuados. LibSass, la biblioteca en la que se apoyaba node-sass, está obsoleta, y Ruby Sass dejó de mantenerse hace años. Usa siempre el paquete sass.
Una estructura de carpetas para arrancar
Antes de escribir código, decide cómo repartir los archivos. Una organización sencilla pero escalable separa lo abstracto (variables, mixins, funciones) de lo concreto (estilos de componentes y páginas). Este es el esquema que usaremos:
tienda-sass/
├── index.html
├── package.json
├── css/
│ └── estilos.css
└── scss/
├── estilos.scss
├── abstractos/
│ ├── _index.scss
│ ├── _variables.scss
│ ├── _mixins.scss
│ └── _funciones.scss
├── base/
│ └── _reset.scss
└── componentes/
├── _boton.scss
└── _tarjeta.scss
Los archivos cuyo nombre empieza con guion bajo son parciales (partials). Le indican a Sass que ese archivo está pensado para ser cargado desde otro y no debe generar su propio CSS al compilar el directorio. Al cargarlos se omiten el guion bajo y la extensión. Solo estilos.scss producirá salida, y esa salida será css/estilos.css.
Variables: un único lugar para tus decisiones de diseño
Las variables de Sass se declaran con el símbolo $. Guardan colores, tamaños, tipografías o cualquier valor que quieras reutilizar. Crea scss/abstractos/_variables.scss:
$color-marca: #0b6e4f;
$color-acento: #f4a259;
$color-texto: #1d2733;
$fuente-base: "Inter", system-ui, sans-serif;
$espacio-m: 1rem;
$radio-borde: 0.5rem;
Cuando cambias $color-marca, todo el proyecto lo refleja tras recompilar. Esto parece trivial, pero es la base de cualquier sistema de diseño coherente.
Una diferencia importante respecto a las propiedades personalizadas de CSS: las variables de Sass desaparecen en tiempo de compilación. El navegador nunca las ve, solo recibe los valores ya sustituidos. Por tanto no pueden cambiar en tiempo de ejecución, por ejemplo al alternar un tema oscuro con JavaScript. Para eso necesitas var(--nombre). Más adelante verás cómo combinar ambas herramientas con sentido.
Las variables también tienen ámbito. Una declarada fuera de cualquier bloque es de nivel superior del módulo; una declarada dentro de un bloque solo existe allí. Si quieres que un valor sea reemplazable desde fuera, añade la marca !default:
$radio-borde: 0.5rem !default;
Con esa marca, el valor solo se asigna si nadie definió antes la variable. Es el mecanismo que usan las librerías para ofrecer valores configurables, y lo retomaremos al hablar de @use ... with.
Anidamiento y el selector padre
El anidamiento permite escribir los selectores hijos dentro del padre, reflejando la estructura del HTML y evitando repetir prefijos. Crea scss/componentes/_tarjeta.scss:
.tarjeta {
padding: 1.5rem;
background: white;
border-radius: 0.5rem;
h2 {
margin: 0 0 0.5rem;
}
p {
line-height: 1.6;
}
a {
color: #0b6e4f;
&:hover {
text-decoration: underline;
}
}
}
El símbolo & representa el selector padre completo. En el ejemplo, &:hover se compila como .tarjeta a:hover. Es muy útil también para modificadores y sufijos al estilo BEM:
.menu {
display: flex;
&__item {
padding: 0.5rem 1rem;
&--activo {
font-weight: 700;
}
}
}
Lo anterior genera .menu__item y .menu__item--activo sin repetir el nombre del bloque. Otro uso habitual es colocar el padre al final, con & detrás: .oscuro & { ... } produce .oscuro .tarjeta.
Conviene una advertencia: el anidamiento profundo es una trampa. Cada nivel añade especificidad y acopla el CSS a la estructura exacta del HTML. Una regla práctica es no pasar de tres niveles. Si lo necesitas, probablemente falta un nombre de clase más expresivo.
Módulos con @use: adiós a @import
Esta es la parte donde más han cambiado las cosas. Durante años, la forma de dividir estilos fue @import. Hoy está obsoleta en Sass y se retirará en una versión mayor futura. Sus problemas eran reales: todo lo importado se volcaba en un espacio global compartido, los nombres chocaban, y un archivo se evaluaba cada vez que se importaba.
El sistema de módulos reemplaza todo eso con @use. Cada archivo cargado crea un espacio de nombres propio, y accedes a sus miembros con un prefijo. Pruébalo en scss/estilos.scss:
@use "abstractos/variables";
@use "base/reset";
@use "componentes/boton";
@use "componentes/tarjeta";
body {
font-family: variables.$fuente-base;
color: variables.$color-texto;
}
Observa tres detalles. Primero, el espacio de nombres es por defecto el último segmento de la ruta: variables. Segundo, la variable se accede como variables.$fuente-base, con el punto entre el módulo y el miembro. Tercero, no hace falta escribir _ ni .scss.
Puedes renombrar el espacio de nombres con as, o eliminarlo con as * si prefieres acceso directo, algo razonable para tus propios archivos de variables pequeños:
@use "abstractos/variables" as v;
@use "abstractos/mixins" as *;
.cabecera {
background: v.$color-marca;
}
Otra regla clave: los @use deben ir al principio del archivo, antes de cualquier regla de estilo, aunque pueden ir después de comentarios y de declaraciones @forward. Además, un módulo se evalúa una sola vez aunque lo cargues desde varios sitios, así que el CSS que emite no se duplica.
Los miembros cuyo nombre empieza por guion o guion bajo son privados del módulo. Si declaras $-ayuda: 4px; en un archivo, no podrá leerse desde fuera. Es una forma sencilla de ocultar detalles de implementación.
Reunir módulos con @forward
Cargar cada archivo de abstractos/ por separado resulta incómodo. Para eso existe @forward, que reexporta los miembros de otro módulo sin usarlos tú mismo. Crea scss/abstractos/_index.scss:
@forward "variables";
@forward "mixins";
@forward "funciones";
Sass trata un archivo llamado _index.scss como la entrada de su carpeta. Gracias a eso, el consumidor escribe una sola línea:
@use "abstractos" as a;
.aviso {
color: a.$color-acento;
padding: a.$espacio-m;
}
@forward admite filtros con show y hide, y un prefijo con as, lo cual ayuda a evitar colisiones cuando reexportas módulos de terceros:
@forward "variables" as var-*;
@forward "mixins" hide mixin-interno;
El primer caso expone var-color-marca en lugar de color-marca. Es útil en librerías grandes, menos en un proyecto pequeño. Úsalo cuando haya una razón concreta.
Configurar módulos con with
Recuerda la marca !default. Combinada con @use ... with, permite parametrizar un módulo al cargarlo. Define en _variables.scss valores por defecto:
$color-marca: #0b6e4f !default;
$radio-borde: 0.5rem !default;
Y en el archivo principal, sobrescribe lo que necesites:
@use "abstractos/variables" with (
$color-marca: #7a1fa2,
$radio-borde: 1rem
);
Existe una restricción: la configuración solo puede aplicarse la primera vez que el módulo se carga. Si otro archivo ya lo cargó sin configuración, recibirás un error. Por eso, en proyectos grandes, el archivo de entrada es el sitio natural para configurar, antes que cualquier otro @use que dependa de él.
Este es exactamente el mecanismo que permite personalizar frameworks grandes sin tocar su código fuente. Si quieres verlo en un caso real, mira cómo se aplica en la guía para personalizar Bootstrap 5 con Sass de forma profesional.
Mixins: bloques de estilo reutilizables
Un mixin agrupa declaraciones que se repiten. Se define con @mixin y se aplica con @include. Crea scss/abstractos/_mixins.scss:
@mixin centrar-flex {
display: flex;
justify-content: center;
align-items: center;
}
@mixin cuadricula($columnas: 3, $hueco: 1rem) {
display: grid;
grid-template-columns: repeat($columnas, 1fr);
gap: $hueco;
}
Para usarlos:
@use "../abstractos" as a;
.hero {
@include a.centrar-flex;
min-height: 60vh;
}
.galeria {
@include a.cuadricula(4, 2rem);
}
.galeria--compacta {
@include a.cuadricula($hueco: 0.5rem);
}
Los argumentos pueden tener valores por defecto y pasarse por nombre, lo que vuelve las llamadas muy legibles. Si necesitas profundizar en los distintos modos de paso de parámetros, incluidos los argumentos variables, tienes un recorrido completo en cómo pasar argumentos a mixins en Sass.
Un patrón muy potente es el mixin que recibe un bloque de contenido con @content. Sirve para encapsular media queries y mantener los puntos de ruptura en un solo sitio:
$puntos: (
"tablet": 768px,
"escritorio": 1100px
);
@mixin desde($nombre) {
@media (min-width: map.get($puntos, $nombre)) {
@content;
}
}
Para que ese código funcione, el archivo necesita cargar el módulo de mapas en su primera línea:
@use "sass:map";
Después, el uso queda así:
.barra-lateral {
display: none;
@include desde("tablet") {
display: block;
width: 18rem;
}
}
La media query se escribe junto a la regla que afecta, en lugar de acumularse al final del archivo. Si mañana el punto de ruptura del tablet cambia, modificas un solo número.
Una nota sobre el criterio: no conviertas todo en mixin. Si el bloque no recibe parámetros y solo repite propiedades, una clase utilitaria o un placeholder suelen ser mejores, porque un mixin copia sus declaraciones en cada lugar donde se incluye y hace crecer el CSS final.
Funciones y aritmética sin trampas
Las funciones se parecen a los mixins pero devuelven un valor en lugar de emitir estilos. Se definen con @function y @return. Un ejemplo clásico es convertir píxeles a rem. En _funciones.scss:
@use "sass:math";
@function a-rem($pixeles, $base: 16) {
@return math.div($pixeles, $base) * 1rem;
}
Y su uso:
h1 {
font-size: a.a-rem(40); // 2.5rem
margin-bottom: a.a-rem(24); // 1.5rem
}
Fíjate en math.div(). Antes se escribía $pixeles / $base, pero el operador / como división está obsoleto, porque en CSS la barra también separa valores, como en font: 16px/1.5 o en grid-area. Sass resolvió la ambigüedad con funciones explícitas. Si ves tutoriales que dividen con /, recibirás avisos de deprecación al compilar.
El módulo sass:math ofrece más utilidades: math.round(), math.ceil(), math.floor(), math.max(), math.min(), math.percentage(), además de constantes como math.$pi. Los operadores +, -, * y % siguen funcionando con normalidad, siempre que las unidades sean compatibles. Sumar 10px + 2em produce un error, y es bueno que lo haga: te avisa de una operación sin sentido.
.columna {
width: math.percentage(math.div(1, 3)); // 33.3333333333%
padding: 8px * 2; // 16px
}
Trabajar con color sin funciones obsoletas
Las clásicas lighten() y darken() aparecen en infinidad de ejemplos, pero las funciones globales de color están en retirada. La alternativa moderna es el módulo sass:color, con funciones como color.adjust() y color.scale():
@use "sass:color";
$base: #0b6e4f;
.boton {
background: $base;
&:hover {
background: color.adjust($base, $lightness: -8%);
}
&:disabled {
background: color.scale($base, $saturation: -60%);
}
}
color.adjust suma o resta una cantidad absoluta a un canal, mientras que color.scale mueve el valor proporcionalmente entre el actual y el máximo o mínimo posible. Para tonos que deben comportarse bien con cualquier color de partida, scale suele dar resultados más predecibles. En la práctica, muchos equipos generan una paleta completa de tonos a partir de un color de marca y la guardan en un mapa.
Ten en cuenta que los espacios de color modernos de CSS, como oklch, ya permiten ajustar luminosidad directamente en el navegador con color-mix() o sintaxis de color relativo. Si tu público lo permite, puedes combinar ambas cosas: Sass genera la estructura y los tokens, CSS nativo se encarga de los matices en ejecución.
Control de flujo: condiciones, bucles y mapas
Sass incluye @if, @else, @each y @for, además de mapas, que son pares clave y valor. Con ellos puedes generar familias de clases sin escribirlas a mano. Considera un mapa de colores semánticos:
@use "sass:map";
$estados: (
"exito": #2e7d32,
"aviso": #ed6c02,
"error": #c62828
);
@each $nombre, $color in $estados {
.alerta--#{$nombre} {
background: color.scale($color, $lightness: 85%);
border-left: 4px solid $color;
color: color.scale($color, $lightness: -30%);
}
}
La interpolación #{ } inserta el valor de una variable dentro de un nombre de selector o de propiedad. Esta construcción compila a tres clases: .alerta--exito, .alerta--aviso y .alerta--error. Añadir un cuarto estado es cuestión de una línea en el mapa.
Las condiciones sirven para variar el resultado según un argumento. Por ejemplo, un mixin de tema:
@mixin tema($modo) {
@if $modo == "oscuro" {
background: #121212;
color: #f1f1f1;
} @else if $modo == "claro" {
background: #ffffff;
color: #1d2733;
} @else {
@error "Modo desconocido: #{$modo}";
}
}
La directiva @error detiene la compilación con un mensaje claro, lo que convierte tus mixins en componentes con validación. También existen @warn para avisos no bloqueantes y @debug para imprimir valores durante el desarrollo.
Para repeticiones numéricas, @for recorre un rango:
@for $i from 1 through 4 {
.margen-#{$i} {
margin: #{$i * 0.25}rem;
}
}
Genera .margen-1 hasta .margen-4. Recuerda no abusar: cada clase generada pesa en el CSS final, y producir cientos de utilidades que nadie usa es un error frecuente.
Placeholders y @extend
@extend permite que un selector herede los estilos de otro, agrupando ambos en una sola regla compilada. Funciona mejor junto a los selectores placeholder, que empiezan con % y no generan salida por sí mismos:
%caja-base {
padding: 1rem;
border-radius: 0.5rem;
border: 1px solid #ddd;
}
.aviso {
@extend %caja-base;
background: #fff8e1;
}
.nota {
@extend %caja-base;
background: #e3f2fd;
}
El resultado en CSS es un único bloque .aviso, .nota { ... } con los estilos comunes, seguido de las reglas específicas. Si el placeholder nunca se extiende, no aparece nada en el archivo compilado.
Úsalo con cuidado. @extend reescribe selectores y, en proyectos grandes, puede generar listas de selectores enormes e imprevisibles, o depender del orden de las reglas. Un criterio razonable: mixin cuando necesitas parámetros o contenido variable, placeholder cuando son estilos idénticos y estáticos, y en caso de duda, una clase utilitaria en el HTML.
Compilar, vigilar y optimizar la salida
Ya tienes el código, ahora falta convertirlo en CSS. El comando básico recibe el archivo de entrada y el de salida:
npx sass scss/estilos.scss css/estilos.css
Durante el desarrollo querrás recompilar automáticamente cuando guardes cambios. La bandera --watch lo hace por ti:
npx sass --watch scss/estilos.scss:css/estilos.css
Además, puedes compilar carpetas completas con la notación origen:destino, y los parciales se ignoran de forma automática:
npx sass --watch scss:css
Para producción, pide una salida comprimida y sin mapas de fuente si no los necesitas:
npx sass --style=compressed --no-source-map scss/estilos.scss css/estilos.min.css
Por defecto, Sass genera un archivo .css.map junto al CSS. Ese mapa de fuentes permite que las herramientas de desarrollo del navegador muestren la línea original del SCSS en lugar de la línea del CSS generado, algo muy valioso al depurar. Nunca edites a mano ni el CSS ni el mapa: se sobrescriben en cada compilación.
Si tus estilos importan paquetes instalados con npm, añade la ruta de carga correspondiente con --load-path:
npx sass --load-path=node_modules scss/estilos.scss css/estilos.css
Con ello puedes escribir @use "bootstrap/scss/bootstrap"; sin rutas relativas largas.
Para que no tengas que recordar los comandos, guárdalos como scripts en package.json:
{
"scripts": {
"sass:dev": "sass --watch scss:css",
"sass:build": "sass --style=compressed --no-source-map scss:css"
}
}
Y ejecútalos con npm run sass:dev o npm run sass:build. Si usas un empaquetador como Vite, Webpack o un framework, lo habitual es instalar sass y dejar que la herramienta compile los archivos .scss por su cuenta; solo cambiará la configuración, no el código SCSS.
Prefijos de navegador y otras tareas fuera de Sass
Un error de concepto bastante común es creer que Sass añade prefijos de proveedor, como -webkit-, automáticamente. No lo hace. Sass compila su propio lenguaje; los prefijos y la compatibilidad con navegadores antiguos los gestiona otra herramienta, normalmente PostCSS con Autoprefixer, o directamente el empaquetador. Hoy en día, con los navegadores modernos, la necesidad de prefijos es mucho menor que hace una década, y conviene decidir según la lista de navegadores que tu proyecto debe soportar.
Del mismo modo, Sass no minimiza más allá de eliminar espacios con --style=compressed, ni purga clases que no usas. Para eso se combinan otras utilidades en la cadena de construcción.
Errores frecuentes y cómo resolverlos
Con el tiempo se repiten siempre los mismos tropiezos. Estos son los más habituales y su solución.
El primero es el mensaje de que una variable no está definida, que casi siempre se debe al uso de @use sin el espacio de nombres. Si cargas @use "abstractos/variables"; y escribes $color-marca, falla. Debes escribir variables.$color-marca o cargar con as *.
El segundo es que @use debe aparecer antes de cualquier otra regla. Si lo colocas después de un selector, Sass lo rechaza. Súbelo al comienzo del archivo.
El tercero es la configuración de un módulo ya cargado. Si recibes un error indicando que el módulo ya fue cargado sin configuración, reorganiza para que el @use ... with sea el primero en ejecutarse.
El cuarto son los avisos de deprecación por / como división o por funciones globales de color. Aunque el CSS se genera bien, esos avisos son una señal de que el código dejará de funcionar en una versión mayor. Sustituye por math.div() y las funciones de sass:color. Si hay avisos que provienen de una dependencia externa y no de tu código, Sass permite silenciarlos selectivamente con opciones como --quiet-deps.
El quinto es un parcial que no aparece en el CSS. Es lo esperado si el parcial no se carga desde ningún archivo de entrada, o si solo define variables y mixins, que no emiten estilos por sí mismos.
El sexto, ya comentado, es el anidamiento excesivo que genera selectores de especificidad enorme y difíciles de sobrescribir. Revisa el CSS compilado de vez en cuando: es la mejor manera de notar un problema que en el SCSS no se ve.
Buenas prácticas para proyectos mantenibles
Algunas costumbres marcan la diferencia a medida que crece la base de código.
Divide por responsabilidad, no por tamaño. Variables, mixins y funciones en una carpeta de abstractos que no emite CSS; reset y tipografía en una de base; y cada componente en su propio parcial. La estructura del ejemplo inicial sigue esa lógica y escala bien.
Nombra las variables por su función y no por su valor. $color-marca envejece mejor que $verde, porque el día que la marca cambie a azul no tendrás una variable mentirosa. Un nivel intermedio es separar la paleta bruta ($verde-600) de los roles semánticos ($color-exito).
Combina variables de Sass con propiedades personalizadas de CSS cuando necesites cambiar valores en tiempo de ejecución. Una técnica frecuente es definir los tokens en Sass y emitirlos como propiedades personalizadas:
@use "abstractos" as a;
:root {
--color-marca: #{a.$color-marca};
--espacio-m: #{a.$espacio-m};
}
.boton {
background: var(--color-marca);
padding: var(--espacio-m);
}
Observa la interpolación #{ }, necesaria para que Sass imprima el valor dentro de una propiedad personalizada en lugar de tratarlo como texto sin evaluar. Con este patrón mantienes un único origen de verdad y conservas la flexibilidad del tema dinámico.
Comenta el porqué y no el qué. Los comentarios con // no aparecen en el CSS compilado, mientras que los de bloque /* */ sí, salvo en modo comprimido. Usa los primeros para notas internas.
Limita el alcance de los mixins con parámetros útiles y valores por defecto razonables, y documenta con un comentario qué hace cada uno. Un mixin con siete parámetros posicionales suele indicar que debería dividirse.
Automatiza una revisión de estilo. Herramientas como Stylelint, con una configuración para SCSS, detectan anidamientos excesivos, orden de propiedades inconsistente o uso de funciones obsoletas, y pueden ejecutarse en tu integración continua.
Por último, fija la versión del compilador en package.json y actualiza de forma deliberada, leyendo las notas de versión. Las deprecaciones se anuncian con antelación, y un proyecto que las atiende poco a poco evita migraciones traumáticas.
Sass frente a CSS nativo: cuándo usar cada uno
Es razonable preguntarse si Sass sigue siendo necesario. La respuesta depende de lo que construyas.
CSS nativo ya cubre varias de las razones históricas. Las propiedades personalizadas ofrecen variables dinámicas, el anidamiento nativo funciona en los navegadores actuales, @import nativo existe aunque con otros costes, y las capas con @layer ayudan a controlar la cascada. Para un sitio pequeño o un componente aislado, puedes prescindir del preprocesador y ahorrarte el paso de compilación.
Sass conserva ventajas claras en otros escenarios. Los bucles y mapas generan utilidades y escalas sin repetición. Las funciones propias calculan valores en tiempo de compilación. El sistema de módulos organiza código con espacios de nombres y privacidad que CSS no tiene. Y un enorme ecosistema de frameworks y sistemas de diseño existentes está escrito en Sass, de modo que para personalizarlos necesitas entenderlo.
Una estrategia equilibrada, cada vez más extendida, es usar Sass para lo que ocurre en construcción (tokens, escalas, bucles, organización) y CSS nativo para lo que ocurre en ejecución (temas, estados, ajuste responsivo con clamp() y consultas de contenedor). Ambos mundos se complementan en lugar de competir.
Conclusiones
Sass te permite escribir hojas de estilo más ordenadas, con menos repetición y con una estructura que escala. Con SCSS mantienes la familiaridad de CSS y añades variables, anidamiento, mixins, funciones, mapas y control de flujo. Lo esencial en la actualidad es trabajar con Dart Sass, la implementación mantenida de la serie 1.x, e instalarlo como dependencia local del proyecto.
Lo más importante a retener es la forma moderna de hacer las cosas: organiza el código con @use y @forward en lugar de @import, divide con math.div() y no con la barra, ajusta colores con sass:color, y recuerda que las variables de Sass existen solo al compilar. Evita el anidamiento profundo, reserva @extend para casos estáticos y revisa de vez en cuando el CSS generado.
Para continuar, toma el proyecto de ejemplo y amplíalo: añade un mapa de espaciados, un mixin de puntos de ruptura, un par de componentes más y un script de compilación en package.json. Cuando te sientas cómodo, prueba a configurar un framework con @use ... with y a exportar tus tokens como propiedades personalizadas. Esa práctica consolidará los conceptos mucho más que la lectura.
