Skip to content

CSS3 Hoja de referencia

La evolución más reciente de CSS, con módulos para estilos, layout y animación.

01

Selectores

Selectores de atributo y pseudo-clases

CSS3 introdujo potentes selectores de atributo y pseudo-clases. ^= coincide con el prefijo, $= con el sufijo, *= con una subcadena. nth-child permite el rayado cebra sin JavaScript.

css3
/* attribute selectors */
input[type="text"] { border: 1px solid blue; }
a[href^="https"] { color: green; }
a[href$=".pdf"] { color: red; }
a[href*="example"] { font-weight: bold; }

/* pseudo-classes */
a:visited { color: purple; }
li:first-child { font-weight: bold; }
li:nth-child(odd) { background: #f0f0f0; }
input:focus { outline: 2px solid blue; }

Pseudo-clases estructurales

Las pseudo-clases estructurales seleccionan elementos por su posición en el DOM. :first-child / :last-child apuntan a los bordes. nth-child(an+b) soporta fórmulas: 2n es par, 2n+1 es impar, 3n es cada tercero. :nth-of-type cuenta solo los hermanos del mismo tipo de elemento. :empty coincide con elementos sin hijos.

css3
/* positional pseudo-classes */
li:first-child { color: green; }
li:last-child { color: red; }
li:only-child { font-weight: bold; }

/* nth variants */
li:nth-child(3) { color: blue; }
li:nth-child(2n+1) { background: #eee; } /* odd */
li:nth-last-child(2) { color: orange; }

/* type-based */
p:first-of-type { font-size: 1.2em; }
p:nth-of-type(even) { color: gray; }
div:empty { display: none; }

:is, :where y :has

:is() y :where() agrupan selectores por brevedad. La diferencia: :is() toma la especificidad más alta de sus argumentos, mientras que :where() siempre tiene especificidad cero — ideal para estilos base de baja especificidad fáciles de sobrescribir. :has() es el tan esperado selector padre/relacional, que permite estilizar un elemento en función de sus descendientes.

css3
/* :is() - matches any selector in the list */
:is(h1, h2, h3) { color: navy; }
:is(.btn, .link):hover { opacity: 0.8; }

/* :where() - same as :is but zero specificity */
:where(article, section) p { line-height: 1.6; }

/* :has() - parent selector (selects element that has a match) */
div:has(> img) { padding: 0; }
card:has(.badge) { border-color: gold; }
form:has(input:invalid) button { opacity: 0.5; }

Negación y pseudo-clases de formularios

:not() niega un selector y ahora acepta una lista. Las pseudo-clases de formularios (:required, :valid, :invalid, :checked, :placeholder-shown, :in-range) permiten estilizar según el estado del input sin JavaScript — genial para retroalimentación de validación en línea y estilo personalizado de checkbox/radio.

css3
/* :not() excludes matching elements */
input:not([type="checkbox"]) { display: block; }
li:not(:last-child) { border-bottom: 1px solid #ddd; }

/* form state pseudo-classes */
input:required { border-color: red; }
input:optional { border-color: #ccc; }
input:valid { border-color: green; }
input:invalid { border-color: red; }
input:in-range { color: black; }
input:out-of-range { color: red; }
input:placeholder-shown { background: #fafafa; }
input:checked + label { font-weight: bold; }

Especificidad y cascada

La especificidad decide qué regla se aplica cuando los selectores entran en conflicto. Cuenta IDs, clases y elementos como (a,b,c). !important sobrescribe la cascada pero rompe el mantenimiento — evítalo. Cuando hay empate de especificidad, gana la regla que aparezca después en el orden del código. DevTools muestra la cascada calculada.

css3
/* specificity ranking: inline > ID > class/attr/pseudo > type/element */
#nav .item { color: red; }     /* 1,1,0 */
.menu .item { color: blue; }   /* 0,2,0 */
li.item { color: green; }      /* 0,1,1 */

/* !important overrides normal declarations */
.btn { color: white !important; }

/* source order wins on equal specificity */
.late { color: purple; }  /* wins over .early */
02

Modelo de caja

box-sizing

box-sizing: border-box incluye padding y borde dentro del width/height declarado, haciendo el dimensionado predecible. content-box (por defecto) los añade por encima. Aplicar border-box globalmente es el reset de CSS más importante — elimina los dolores de cabeza de cálculo de layout más comunes.

css3
/* default: width = content only */
.box-content { box-sizing: content-box; width: 200px; padding: 20px; } /* total 240px */

/* padding & border inside width */
.box-border { box-sizing: border-box; width: 200px; padding: 20px; border: 2px solid; } /* total 200px */

/* universal reset - apply everywhere */
*, *::before, *::after {
  box-sizing: border-box;
}

Margen y padding

El padding está dentro del borde (hereda el fondo); el margen está fuera (transparente). Los márgenes verticales entre elementos de bloque adyacentes se colapsan al valor mayor — los horizontales nunca colapsan. margin: 0 auto centra un elemento de bloque con ancho definido. Los márgenes negativos pueden tirar del contenido pero úsalos con moderación.

css3
.box {
  /* top right bottom left (clockwise) */
  margin: 10px 20px 15px 25px;
  /* 2 values: vertical horizontal */
  padding: 10px 20px;
  /* single value: all sides */
  margin: 0 auto; /* horizontal centering for fixed-width block */
}

/* margin collapse (vertical only) */
.a { margin-bottom: 30px; }
.b { margin-top: 20px; }
/* gap between .a and .b = 30px, not 50px (collapsed to larger) */

/* negative margins pull elements together */
.pull-left { margin-left: -10px; }

box-shadow

Sintaxis de box-shadow: offset-x offset-y blur-radius spread-radius color. Los offsets positivos empujan la sombra a la derecha/abajo. inset crea una sombra interna. Varias sombras se apilan con la primera encima. Usa rgba para sombras translúcidas y naturales. Las sombras duras (blur cero) crean una estética plana y contundente.

css3
/* offset-x offset-y blur spread color */
.card { box-shadow: 0 4px 6px rgba(0,0,0,0.1); }

/* inset shadow (inside the box) */
.inset { box-shadow: inset 0 2px 4px rgba(0,0,0,0.2); }

/* multiple shadows (first = top layer) */
.layered { box-shadow: 0 1px 2px #000, 0 8px 24px rgba(0,0,0,0.15); }

/* no blur, hard shadow (neo-brutalism) */
.hard { box-shadow: 6px 6px 0 #000; }

/* glow effect */
.glow { box-shadow: 0 0 20px rgba(0,150,255,0.6); }

Tipos de display

display: none elimina el elemento del layout (no reserva espacio). Los elementos block ocupan el ancho completo y se apilan verticalmente; los inline fluyen con el texto e ignoran width/height. inline-block combina el flujo en línea con el dimensionado de bloque. flow-root limpia floats sin hacks de clearfix. contents hace desaparecer la caja manteniendo los hijos en el layout.

css3
/* block: full width, new line */
div, p { display: block; }

/* inline: flows with text, ignores width/height */
span, a { display: inline; }

/* inline-block: flows inline but accepts width/height */
.tag { display: inline-block; width: 100px; }

/* none: removed from layout entirely */
.hidden { display: none; }

/* modern display values */
.flow { display: flow-root; } /* new block formatting context */
.contents { display: contents; } /* element's box disappears, children participate */

Overflow

overflow controla cómo se maneja el contenido que excede la caja. visible (por defecto) deja que se derrame; hidden lo recorta; auto añade barras de scroll cuando hacen falta; scroll siempre las muestra. clip (más nuevo) es como hidden pero impide cualquier scroll, incluso por JS. Usa overflow-y/x para controlar los ejes por separado. Fijar overflow a cualquier valor distinto de visible crea un nuevo contexto de formato.

css3
.scrollable {
  overflow: auto;       /* scrollbars when needed */
  overflow-y: scroll;   /* always show vertical scrollbar */
  overflow-x: hidden;   /* hide horizontal overflow */
}

/* visible (default) - content spills out */
.spill { overflow: visible; }

/* clip - like hidden but no programmatic scroll */
.clipped { overflow: clip; }

/* clip to a shape */
.custom-clip {
  overflow: clip;
  overflow-clip-margin: 20px;
}

/* longhand for both axes */
.both { overflow-x: hidden; overflow-y: auto; }
03

Flexbox

Contenedor flex

display: flex convierte un elemento en contenedor flex. justify-content alinea los ítems a lo largo del eje principal (horizontal en fila); align-items alinea en el eje transversal. flex-wrap permite que los ítems pasen a nuevas líneas. gap reemplaza el hack de espaciado con márgenes. Flexbox brilla en layouts unidimensionales (filas o columnas).

css3
.container {
  display: flex;
  flex-direction: row;       /* row | row-reverse | column | column-reverse */
  justify-content: center;   /* main axis: flex-start | center | space-between | space-around | space-evenly */
  align-items: center;       /* cross axis: stretch | flex-start | center | baseline */
  flex-wrap: wrap;           /* nowrap | wrap | wrap-reverse */
  gap: 16px;                 /* spacing between items */
  align-content: space-between; /* multi-line spacing */
}

Ítems flex

flex-grow controla cuánto se expande un ítem para llenar el espacio extra (1 = cuota igual). flex-shrink controla el encogimiento. flex-basis es el tamaño inicial. La forma corta flex: 1 significa crecer por igual desde base cero — perfecto para columnas iguales. align-self sobrescribe el align-items del contenedor para un solo ítem. order reordena visualmente sin cambiar el orden del DOM.

css3
.item {
  flex-grow: 1;     /* grow to fill extra space (0 = don't grow) */
  flex-shrink: 1;   /* shrink when space is tight (0 = don't shrink) */
  flex-basis: 200px; /* initial size before growing/shrinking */
  
  /* shorthand: flex: grow shrink basis */
  flex: 1 1 200px;   /* flexible from 200px */
  flex: 1;            /* = 1 1 0% - equal distribution */
  flex: 0 0 250px;    /* fixed width, no grow/shrink */
  
  align-self: flex-end; /* override align-items for this item */
  order: 2;             /* visual reordering (default 0) */
}

Patrones de alineación flex

Flexbox hace el centrado trivial: justify-content: center + align-items: center. Un footer pegajoso usa un body flex en columna con min-height: 100vh y el contenido principal con flex: 1. Para barras de navegación, space-between empuja el primer y el último ítem a los bordes opuestos. Los márgenes automáticos (margin-left: auto) son una alternativa flexible a justify-content para empujar ítems.

css3
/* perfect centering */
.center {
  display: flex;
  justify-content: center;
  align-items: center;
  min-height: 100vh;
}

/* sticky footer: body is flex column */
body { display: flex; flex-direction: column; min-height: 100vh; }
main { flex: 1; } /* grows to fill, pushing footer down */

/* navbar: space between */
.nav { display: flex; justify-content: space-between; }

/* auto margins absorb space */
.push-right { margin-left: auto; }

Flex wrap y cuadrícula responsiva

flex-wrap: wrap permite que los ítems pasen a nuevas líneas cuando se quedan sin espacio. flex: 1 1 280px crea tarjetas que empiezan en 280px y crecen para llenar la fila. Esto produce una cuadrícula de tarjetas responsiva sin media queries. Ojo: los ítems de la última fila se estiran para llenar, lo que puede verse desigual — para cuadrículas de tarjetas consistentes, CSS Grid suele ser mejor opción.

css3
.cards {
  display: flex;
  flex-wrap: wrap;
  gap: 20px;
}

.card {
  /* start at 280px, grow & shrink fluidly */
  flex: 1 1 280px;
  /* prevent stretching beyond readable width */
  max-width: 100%;
}

/* OR fixed-width cards that wrap */
.card-fixed {
  flex: 0 0 300px;
}

/* last row items stretch to fill - to avoid, use grid instead */
/* gap wraps with items automatically */

Flex direction y ejes

flex-direction determina el eje principal. En row (por defecto), justify-content controla la alineación horizontal; en column, controla la vertical — los ejes se intercambian. Pregúntate siempre '¿cuál es el eje principal?' al alinear. row-reverse y column-reverse invierten el orden de los ítems, lo que también afecta a cómo justify-content reparte el espacio.

css3
/* row: main axis = horizontal */
.row { display: flex; flex-direction: row; justify-content: center; }

/* column: main axis = vertical (axes swap!) */
.col { display: flex; flex-direction: column; align-items: center; }

/* reverse order */
.reverse { display: flex; flex-direction: row-reverse; }

/* centering in column: justify-content centers vertically */
.col-center {
  display: flex;
  flex-direction: column;
  justify-content: center; /* vertical center */
  align-items: center;     /* horizontal center */
}
04

Grid Layout

Contenedor grid

display: grid crea un layout bidimensional. grid-template-columns define las pistas de columna; la unidad fr reparte el espacio libre proporcionalmente. repeat(auto-fit, minmax(200px, 1fr)) es la receta mágica para cuadrículas responsivas — las columnas se crean y redimensionan solas sin media queries. gap añade espacio entre pistas de forma limpia.

css3
.grid {
  display: grid;
  /* fixed columns */
  grid-template-columns: 200px 1fr 200px;
  /* responsive auto columns */
  grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
  grid-template-rows: auto 1fr auto;
  gap: 20px;            /* row + column gap */
  row-gap: 20px;        /* gap between rows */
  column-gap: 16px;     /* gap between columns */
}

Grid template areas

grid-template-areas permite dibujar el layout visualmente con regiones con nombre — extremadamente legible. Cada cadena entre comillas es una fila; los nombres colocan los ítems y un punto marca una celda vacía. Un ítem con grid-area: name llena esa región. Es la forma más clara de construir layouts a nivel de página como los app shells.

css3
.layout {
  display: grid;
  grid-template-columns: 200px 1fr;
  grid-template-rows: auto 1fr auto;
  grid-template-areas:
    "header header"
    "sidebar main"
    "footer footer";
  min-height: 100vh;
}

.header  { grid-area: header; }
.sidebar { grid-area: sidebar; }
.main    { grid-area: main; }
.footer  { grid-area: footer; }

/* empty cell with a dot */
grid-template-areas: "header header" "sidebar .";

Colocación de ítems del grid

Los ítems del grid pueden colocarse explícitamente por números de línea. grid-column: 1 / 3 abarca desde la línea 1 hasta la 3 (cubriendo 2 columnas). La palabra clave span dimensiona por número de pistas. Las líneas también pueden nombrarse en grid-template-columns por legibilidad. Sin colocación explícita, los ítems fluyen automáticamente hacia las celdas disponibles.

css3
.item {
  /* place by line numbers: row-start / col-start / row-end / col-end */
  grid-column: 1 / 3;      /* span columns 1 to 3 */
  grid-row: 1 / 2;
  
  /* span keyword */
  grid-column: span 2;     /* span 2 columns */
  grid-row: 2 / span 3;
  
  /* shorthand: grid-area: row-start / col-start / row-end / col-end */
  grid-area: 1 / 1 / 3 / 4;
  
  /* name a line and reference it */
  grid-column-start: content-start;
}

Alineación del grid

La alineación del grid funciona en dos niveles. justify-content/align-content posicionan toda la cuadrícula dentro del contenedor cuando sobra espacio. justify-items/align-items alinean los ítems dentro de sus celdas (stretch por defecto). justify-self/align-self sobrescriben la alineación por ítem. 'justify' = eje inline/principal, 'align' = eje bloque/transversal.

css3
.grid {
  display: grid;
  grid-template-columns: repeat(3, 100px);
  
  /* align tracks within container */
  justify-content: center;  /* center the grid horizontally */
  align-content: center;    /* center vertically (needs fixed height) */
  
  /* align items within their cells */
  justify-items: stretch;   /* fill cell width (default) */
  align-items: center;      /* center within cell height */
}

.item {
  justify-self: start;      /* override justify-items for one item */
  align-self: end;
}

auto-fit vs auto-fill

Ambos crean tantas pistas como quepan, pero se comportan distinto con pocos ítems. auto-fit colapsa las pistas sin usar y estira los ítems existentes para llenar la fila. auto-fill conserva las pistas vacías, así que los ítems mantienen su tamaño mínimo. Usa auto-fit cuando quieras que los ítems crezcan y llenen el espacio; usa auto-fill cuando quieras un tamaño de ítem fijo y consistente.

css3
/* auto-fit: empty tracks collapse, items stretch to fill */
.autofit {
  grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
}

/* auto-fill: empty tracks remain, items keep their size */
.autofill {
  grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
}

/* with few items:
   auto-fit -> items stretch to fill the row
   auto-fill -> items stay small, leaving empty columns */
05

Posicionamiento

Valores de position

static es el valor por defecto. relative desplaza un elemento desde su posición normal de flujo (el espacio se conserva). absolute lo saca del flujo y lo posiciona respecto al ancestro posicionado más cercano (o al viewport). fixed es relativo al viewport del navegador. sticky alterna entre relative y fixed según la posición de scroll — ideal para encabezados pegajosos.

css3
/* static - default, flows normally */
.static { position: static; }

/* relative - offset from its normal position */
.relative { position: relative; top: 10px; left: 20px; }

/* absolute - positioned relative to nearest positioned ancestor */
.absolute { position: absolute; top: 0; right: 0; }

/* fixed - positioned relative to viewport (stays on scroll) */
.fixed { position: fixed; bottom: 0; left: 0; }

/* sticky - relative until scroll threshold, then fixed */
.sticky { position: sticky; top: 0; }

Centrado absoluto

Hay varias formas de centrar absolutamente. El truco translate(-50%, -50%) funciona en elementos de cualquier tamaño. La técnica inset: 0 + margin: auto requiere dimensiones explícitas. El enfoque moderno es display: grid con place-items: center (forma corta de align-items + justify-items) — sin cálculos de posicionamiento y la forma más simple.

css3
/* classic: position absolute + transform */
.center {
  position: absolute;
  top: 50%; left: 50%;
  transform: translate(-50%, -50%);
}

/* inset: 0 + margin: auto (needs width/height) */
.center-auto {
  position: absolute;
  inset: 0;          /* top/right/bottom/left: 0 */
  margin: auto;
  width: 300px;
  height: 200px;
}

/* modern: no positioning needed */
.center-grid { display: grid; place-items: center; }

Posicionamiento sticky

position: sticky mantiene un elemento en el flujo normal hasta que alcanza un umbral (por ejemplo, top: 0), y entonces se pega como fixed. Perfecto para encabezados pegajosos o sidebars de índice. Trampa: cualquier ancestro con overflow: hidden/auto/scroll (en la dirección del scroll) se convierte en el bloque contenedor y rompe el comportamiento esperado. Fija siempre un fondo y un z-index en los elementos sticky.

css3
.header {
  position: sticky;
  top: 0;            /* sticks when header hits top of viewport */
  z-index: 100;
  background: white;
}

/* sticky sidebar that scrolls with content until threshold */
.sidebar {
  position: sticky;
  top: 60px;         /* offset below the fixed header */
  max-height: calc(100vh - 60px);
  overflow-y: auto;
}

/* NOTE: a parent with overflow: hidden breaks sticky */

z-index y contextos de apilamiento

z-index solo funciona en elementos posicionados (no static). Un contexto de apilamiento se crea con position + z-index, pero también con opacity < 1, transform, filter, will-change e isolation: isolate. Dentro de un contexto de apilamiento, los valores z-index de los hijos están aislados — un hijo nunca puede renderizar sobre un hermano de un ancestro. Entender esto evita las guerras de escalada de z-index.

css3
.modal { position: fixed; z-index: 1000; }
.overlay { position: fixed; z-index: 999; }
.card { position: relative; z-index: 1; }

/* creating a stacking context (isolates z-index) */
.context {
  position: relative;
  z-index: 0;  /* children's z-index only matters within this */
}

/* other properties that create stacking contexts:
   opacity < 1, transform, filter, will-change, isolation: isolate */
.isolated { isolation: isolate; }

Forma corta inset

inset es la forma corta lógica de top, right, bottom y left — como margin/padding acepta 1, 2 o 4 valores. inset: 0 estira un elemento posicionado absolutamente para llenar su bloque contenedor. Es más limpio que declarar cuatro propiedades separadas y combina bien con margin: auto para centrar.

css3
/* inset sets top right bottom left (like margin) */
.popup {
  position: absolute;
  inset: 0;          /* all sides = 0 (stretches to fill parent) */
}

/* two values: vertical horizontal */
.pill {
  position: absolute;
  inset: 10px 20px;  /* top/bottom 10px, left/right 20px */
}

/* four values: top right bottom left */
.box {
  position: absolute;
  inset: 10px 20px 30px 40px;
}

/* longhand equivalents */
.inset-longhand {
  position: absolute;
  top: 0; right: 0; bottom: 0; left: 0;
}
06

Estilos de texto

Propiedades de fuente

font-family debería terminar siempre con una familia genérica (serif, sans-serif, monospace) como último recurso. font-weight va de 100 a 900; comunes: 400 normal, 700 bold. line-height se define mejor sin unidad (1.5) para que escale con el font-size. La forma corta font exige tamaño y familia; el orden es estilo peso tamaño/interlineado familia.

css3
body {
  font-family: "Helvetica Neue", Arial, sans-serif; /* fallback chain */
  font-size: 16px;
  font-weight: 400;     /* 100-900; 400=normal, 700=bold */
  font-style: italic;   /* normal | italic | oblique */
  line-height: 1.5;     /* unitless = multiplier of font-size */
  letter-spacing: 0.5px;
  word-spacing: 2px;
  font-variant: small-caps;
}

/* shorthand: style weight size/line-height family (order matters) */
p { font: italic 700 16px/1.5 "Georgia", serif; }

Formato de texto

text-align: justify puede crear ríos de espacio en blanco; emparéjalo con hyphens: auto para bloques más limpios. text-decoration ahora acepta line, style y color en una sola forma corta. text-transform: capitalize pone en mayúscula la inicial de cada palabra. white-space: nowrap evita el ajuste de línea. text-shadow acepta offset-x offset-y blur color.

css3
.text {
  text-align: justify;          /* left | right | center | justify */
  text-decoration: underline wavy red; /* line style color */
  text-decoration: line-through;
  text-transform: uppercase;    /* lowercase | capitalize */
  text-indent: 2em;             /* first-line indent */
  white-space: nowrap;          /* prevent wrapping */
  word-break: break-word;       /* break long words */
  hyphens: auto;                /* auto-hyphenate (needs lang attr) */
  text-shadow: 2px 2px 4px rgba(0,0,0,0.5);
}

Desbordamiento de texto y elipsis

El recorte de una sola línea necesita tres propiedades: white-space: nowrap, overflow: hidden, text-overflow: ellipsis. Para el recorte multilínea, usa -webkit-line-clamp con display: -webkit-box (aún requiere el prefijo -webkit- pero funciona en cualquier navegador moderno). Se necesita un max-width o width para que el recorte se active.

css3
.truncate {
  /* three properties required for ellipsis */
  white-space: nowrap;
  overflow: hidden;
  text-overflow: ellipsis;    /* clip | ellipsis */
  max-width: 200px;
}

/* multi-line clamp (line-clamp) */
.clamp {
  display: -webkit-box;
  -webkit-line-clamp: 3;       /* limit to 3 lines */
  -webkit-box-orient: vertical;
  overflow: hidden;
}

/* custom fade effect */
.fade {
  -webkit-mask-image: linear-gradient(to bottom, black 70%, transparent);
}

text-shadow y efectos

text-shadow acepta offset-x offset-y blur-radius color. Varias sombras se apilan con la primera encima — útil para brillos neón o contornos de texto (una sombra en 4 direcciones imita un contorno). A diferencia de -webkit-text-stroke, text-shadow está soportado universalmente. Las sombras duras (sin blur) crean una estética retro tipo pegatina.

css3
/* x-offset y-offset blur color */
.shadow { text-shadow: 2px 2px 4px rgba(0,0,0,0.3); }

/* multiple shadows (first = top) */
.neon { text-shadow: 0 0 10px #fff, 0 0 20px #fff, 0 0 30px #0ff; }

/* 3D letterpress effect */
.letterpress { text-shadow: 0 1px 0 rgba(255,255,255,0.5); }

/* outline text (no blur, light color) */
.outline { text-shadow: -1px -1px 0 #000, 1px -1px 0 #000, -1px 1px 0 #000, 1px 1px 0 #000; }

/* hard shadow retro effect */
.retro { text-shadow: 4px 4px 0 #ff6b6b; }

Modos de escritura y dirección

writing-mode controla la dirección del texto: horizontal-tb (por defecto), vertical-rl (por ejemplo, chino/japonés tradicional) o vertical-lr. direction: rtl maneja los idiomas de derecha a izquierda como el árabe. Las propiedades lógicas (margin-inline-start, padding-block, inset-inline-end) se adaptan automáticamente al modo de escritura y la dirección — esenciales para layouts verdaderamente internacionales e independientes de la dirección.

css3
/* horizontal (default) */
.horizontal { writing-mode: horizontal-tb; }

/* vertical, top to bottom */
.vertical-rl { writing-mode: vertical-rl; }
.vertical-lr { writing-mode: vertical-lr; }

/* text direction */
.rtl { direction: rtl; unicode-bidi: bidi-override; }

/* logical properties adapt to writing mode */
.box {
  margin-inline-start: 10px;   /* logical left in LTR */
  padding-block: 20px;         /* logical top/bottom */
  inset-inline-end: 0;         /* logical right in LTR */
}
07

Fondos y degradados

Forma corta background

La forma corta background acepta todas las propiedades de fondo. Al usar position y size juntos, sepáralos con una barra (center/cover). Los fondos múltiples se apilan separados por comas; el primero declarado es el más alto. Un color sólido debería ir siempre al final como respaldo. Usa cover para llenar la caja y contain para encajar toda la imagen.

css3
.box {
  /* longhand */
  background-color: #fff;
  background-image: url("bg.png");
  background-repeat: no-repeat;
  background-position: center;
  background-size: cover;
  background-attachment: fixed;
  
  /* shorthand (color image position/size repeat attachment) */
  background: #fff url("bg.png") center/cover no-repeat fixed;
}

/* multiple backgrounds (first = top layer) */
.multi {
  background: url("top.png") top left/contain no-repeat,
              url("bottom.png") bottom right/cover no-repeat #eee;
}

Degradados lineales

linear-gradient(dirección, paradas de color) crea una transición suave. La dirección puede ser una palabra clave (to right) o un ángulo (45deg). Las paradas pueden incluir posiciones en porcentajes — colocar dos paradas en la misma posición crea un borde duro (genial para rayas). Los degradados son imágenes, así que van en background-image y pueden usarse donde se acepten imágenes.

css3
/* direction or angle, then color stops */
.gradient { background: linear-gradient(to right, red, blue); }
.gradient-45 { background: linear-gradient(45deg, red, blue); }

/* multiple color stops */
.rainbow { background: linear-gradient(to right, red, orange, yellow, green, blue); }

/* color stops with positions */
.hard-stop { background: linear-gradient(to right, red 0%, red 50%, blue 50%, blue 100%); }

/* transparent stops for fade effects */
.fade { background: linear-gradient(to bottom, rgba(0,0,0,0.5), transparent); }

Degradados radial y cónico

radial-gradient irradia hacia afuera desde un punto central — útil para focos de luz y botones. Puedes posicionar el centro (at top left) y controlar la forma/tamaño (circle, closest-side). conic-gradient rota los colores alrededor de un punto — perfecto para gráficos de pie y ruedas de color. Las paradas duras en degradados cónicos crean porciones de pie limpias.

css3
/* radial: radiates from a center point */
.radial { background: radial-gradient(circle, red, blue); }
.radial-c { background: radial-gradient(circle at top left, #fff, #000); }
.radial-size { background: radial-gradient(closest-side, red, blue); }

/* conic: rotates around a center point */
.pie { background: conic-gradient(red 0% 30%, blue 30% 70%, green 70% 100%); }

/* conic with angle start */
.spin { background: conic-gradient(from 45deg, red, yellow, green, red); }

background-clip y origin

background-clip controla hasta dónde se extiende el fondo: border-box (por defecto, bajo el borde), padding-box (dentro del borde) o content-box (dentro del padding). El truco de titulares: background-clip: text con color: transparent rellena el texto con un degradado o imagen. Incluye siempre la versión con prefijo -webkit- para Safari. background-origin fija el área de posicionamiento.

css3
/* clip: where the background paints */
.border-box { background-clip: border-box; } /* default - under border */
.padding-box { background-clip: padding-box; } /* inside border */
.content-box { background-clip: content-box; } /* inside padding */

/* text clip: gradient-filled text */
.gradient-text {
  background: linear-gradient(to right, red, blue);
  -webkit-background-clip: text;
  background-clip: text;
  color: transparent;
  -webkit-text-fill-color: transparent;
}

/* origin: where positioning starts */
.origin { background-origin: content-box; }

Attachment del fondo y parallax

background-attachment: fixed crea un efecto parallax — el fondo permanece fijo mientras el contenido se desplaza sobre él. scroll (por defecto) se mueve con el elemento; local hace scroll con el contenido del elemento (útil en cajas desplazables). El attachment fijo va a tirones y tiene poco soporte en móvil; para parallax en producción, usa transform: translate3d según la posición de scroll.

css3
/* fixed: background stays put during scroll (parallax) */
.parallax {
  background-image: url("hero.jpg");
  background-attachment: fixed;
  background-size: cover;
  height: 100vh;
}

/* scroll: scrolls with element (default) */
.scroll { background-attachment: scroll; }

/* local: scrolls with element's content */
.local {
  background-attachment: local; /* scrolls with inner content */
}

/* NOTE: background-attachment: fixed has poor mobile support
   prefer transform-based parallax for mobile */
08

Bordes y esquinas redondeadas

border-radius

border-radius redondea esquinas, aceptando 1-4 valores (en sentido horario desde arriba a la izquierda). Una barra separa los radios horizontal/vertical para esquinas elípticas. border-radius: 50% sobre un cuadrado crea un círculo perfecto; sobre un rectángulo, una elipse. Las propiedades largas (border-top-left-radius) controlan esquinas individuales. Las esquinas redondeadas recortan fondos, bordes y (con overflow: hidden) el contenido hijo.

css3
.box { border-radius: 10px; }              /* all corners */
.box-2 { border-radius: 10px 20px; }        /* top-left/bottom-right  top-right/bottom-left */
.box-4 { border-radius: 10px 20px 30px 40px; } /* TL TR BR BL (clockwise) */

/* per-corner longhand */
.card {
  border-top-left-radius: 10px;
  border-top-right-radius: 20px;
  border-bottom-right-radius: 30px;
  border-bottom-left-radius: 40px;
}

/* elliptical corners (horizontal / vertical) */
.ellipse { border-radius: 50px / 25px; }

/* perfect circle (square element) */
.circle { border-radius: 50%; }

border-image

border-image corta una imagen en 9 regiones y aplica las esquinas/bordes a un borde. border-image-slice divide la imagen fuente; repeat controla cómo se teselan los bordes. Un truco moderno común: usar border-image con un linear-gradient y slice 1 para crear bordes con degradado. Ojo: border-image reemplaza a border-style, así que fija primero border-width.

css3
.frame {
  border: 20px solid transparent;
  border-image-source: url("frame.png");
  border-image-slice: 30;        /* slice image into 9 regions */
  border-image-width: 20px;
  border-image-outset: 0;
  border-image-repeat: stretch;  /* stretch | repeat | round | space */
}

/* shorthand */
.frame-shorthand {
  border: 20px solid transparent;
  border-image: url("frame.png") 30 stretch;
}

/* gradient border (using border-image) */
.grad-border {
  border: 4px solid;
  border-image: linear-gradient(to right, red, blue) 1;
}

Bordes múltiples

CSS no puede apilar varias propiedades border, pero hay alternativas. box-shadow con offset cero y spread crea bordes exteriores nítidos (funciona con border-radius). outline dibuja un segundo borde por fuera, pero ignora el border-radius. Un pseudo-elemento da control total, incluido el radio. Cada técnica tiene contrapartidas — elige según necesites esquinas redondeadas.

css3
/* technique 1: box-shadow (no rounded issue) */
.multi-shadow {
  box-shadow: 0 0 0 5px red, 0 0 0 10px blue;
}

/* technique 2: outline (outside border, no radius) */
.outline-border {
  border: 5px solid red;
  outline: 5px solid blue;
  outline-offset: 0;
}

/* technique 3: pseudo-element (full control) */
.pseudo-border {
  position: relative;
  border: 5px solid red;
}
.pseudo-border::after {
  content: "";
  position: absolute;
  inset: -10px;
  border: 5px solid blue;
  border-radius: inherit;
}

Bordes con degradado

Los bordes con degradado son delicados porque border-image no soporta border-radius. La solución robusta: apilar dos fondos — un color sólido recortado a padding-box y un degradado recortado a border-box, con un borde transparente. Esto respeta el border-radius y funciona en todas partes. La variante más simple con border-image sirve cuando no necesitas esquinas redondeadas.

css3
/* method 1: border-image (works but no border-radius) */
.grad-1 {
  border: 4px solid;
  border-image: linear-gradient(to right, red, blue) 1;
}

/* method 2: background-clip trick (works with radius) */
.grad-2 {
  border: 4px solid transparent;
  border-radius: 12px;
  background:
    linear-gradient(white, white) padding-box,
    linear-gradient(to right, red, blue) border-box;
}

/* method 3: mask + pseudo (advanced, supports radius + animation) */

Outline y estilos de foco

outline se dibuja fuera del borde y no afecta al layout, por lo que es ideal para indicadores de foco. outline-offset añade una separación. Regla crítica de accesibilidad: nunca fjes outline: none sin una alternativa visible. :focus-visible muestra el contorno solo para la navegación por teclado (no con el ratón) — el enfoque moderno y amigable para el estilo de foco.

css3
/* outline: doesn't affect layout, draws outside border */
.focusable:focus {
  outline: 2px solid blue;
  outline-offset: 2px;  /* gap between element and outline */
}

/* never use outline: none without a replacement */
button:focus { outline: none; box-shadow: 0 0 0 3px rgba(0,150,255,0.5); }

/* :focus-visible: only shows outline for keyboard users */
button:focus-visible { outline: 2px solid blue; outline-offset: 2px; }
button:focus:not(:focus-visible) { outline: none; }

/* outline shorthand */
.box { outline: 2px dashed red; }
09

Transformaciones

Transformaciones 2D

Las transformaciones 2D — translate, rotate, scale, skew — mueven y distorsionan elementos sin afectar al layout (los hermanos no se refluyen). Combinar transformaciones se aplica de derecha a izquierda, así que el orden importa: rotar antes de trasladar mueve a lo largo del eje rotado. Como las transformaciones no disparan reflow, son ideales para animaciones y están aceleradas por GPU.

css3
.box { transform: translate(50px, 20px); }   /* move right 50, down 20 */
.box-x { transform: translateX(50px); }
.box-scale { transform: scale(1.5); }          /* grow 1.5x */
.box-scale-2 { transform: scale(1, 2); }       /* x 1, y 2 */
.box-rotate { transform: rotate(45deg); }      /* clockwise */
.box-skew { transform: skew(20deg, 10deg); }   /* skew x, y */

/* combine transforms (order matters!) */
.combo { transform: translate(20px, 0) rotate(45deg) scale(1.2); }

/* transform does NOT affect layout (no reflow) */

transform-origin

transform-origin fija el punto pivote de las transformaciones — por defecto es el centro del elemento. Acepta palabras clave (top left), píxeles o porcentajes. Cambiar el origen altera drásticamente el comportamiento de rotación y escalado: una tarjeta que gira sobre su borde superior necesita transform-origin: top. En transformaciones 3D se puede especificar un tercer valor para el eje z.

css3
.box { transform: rotate(45deg); }

/* default origin: center center (50% 50%) */
.center { transform-origin: center center; }

/* rotate around top-left corner */
.tl { transform-origin: top left; transform: rotate(45deg); }

/* custom point (x y) */
.custom { transform-origin: 20px 50px; transform: rotate(45deg); }

/* 3-value form (x y z) */
.three-d { transform-origin: 0 0 100px; }

/* percentage-based */
.pct { transform-origin: 100% 0; } /* top-right corner */

Transformaciones 3D

Las transformaciones 3D añaden rotateX, rotateY, rotateZ, translateZ y scaleZ. perspective(n) debe aplicarse como primera función de transformación (o en el padre) para habilitar la profundidad — valores menores exageran el efecto 3D. translate3d y scale3d están aceleradas por GPU y rinden mejor en animaciones que sus equivalentes 2D.

css3
.card { transform: perspective(1000px) rotateY(45deg); }

/* rotateX/Y/Z - rotate around 3D axes */
.flip { transform: rotateX(180deg); }   /* flip horizontally */
.turn { transform: rotateY(180deg); }   /* flip like a page */
.spin { transform: rotateZ(90deg); }    /* same as rotate() */

/* translate3d (GPU-accelerated) */
.move { transform: translate3d(50px, 20px, 100px); }

/* scale3d */
.grow { transform: scale3d(1.5, 1.5, 1.5); }

/* combined 3D */
.combo-3d { transform: perspective(800px) rotateX(15deg) rotateY(-20deg) translateZ(-50px); }

Perspectiva y espacio 3D

perspective define la distancia del espectador — menor = 3D más dramático. Ponlo en el padre para que cada hijo comparta el mismo punto de fuga. transform-style: preserve-3d permite que los elementos anidados vivan en un espacio 3D compartido (esencial para construir cubos). backface-visibility: hidden oculta la parte trasera de un elemento — clave para efectos de tarjeta volteable.

css3
/* perspective on parent: applies to all children uniformly */
.scene { perspective: 1000px; }
.cube { transform: rotateY(45deg); }

/* perspective() in transform: only affects that element */
.solo { transform: perspective(1000px) rotateY(45deg); }

/* perspective-origin: vanishing point */
.scene { perspective: 1000px; perspective-origin: top left; }

/* transform-style: preserve-3d lets children share 3D space */
.cube {
  transform-style: preserve-3d;
  transform: rotateY(30deg);
}
.cube .face { position: absolute; transform: translateZ(50px); }

/* backface-visibility: hide back of flipped element */
.card { backface-visibility: hidden; }

Animar transformaciones (rendimiento)

Anima siempre transform y opacity — están acelerados por GPU y no disparan layout (reflow) ni paint. Animar top/left/width/margin obliga al navegador a recalcular el layout en cada fotograma, causando tirones. will-change: transform insinúa al navegador que prepare una capa de composición por adelantado, pero el abuso desperdicia memoria. Aplícalo justo antes de una animación y retíralo después.

css3
/* GOOD: animate transform & opacity (GPU-accelerated) */
.smooth {
  transition: transform 0.3s ease;
}
.smooth:hover { transform: translateY(-5px); }

/* BAD: animating top/left triggers reflow */
.janky { transition: top 0.3s; }
.janky:hover { top: -5px; }

/* will-change: hint the browser to optimize */
.prepared {
  will-change: transform;  /* prepare for upcoming transform changes */
}

/* force GPU layer (use sparingly) */
.gpu { transform: translateZ(0); }
10

Transiciones

Forma corta transition

transition: propiedad duración función-tiempo retardo. El valor por defecto es all 0s ease 0s — así que con solo escribir transition: 0.3s se animan todas las propiedades que cambien. Por rendimiento y control, lista propiedades concretas. Varias transiciones van separadas por comas. La transición va en el estado por defecto del elemento (no en :hover), para que la animación inversa también se reproduzca.

css3
.btn {
  background: blue;
  /* shorthand: property duration timing-function delay */
  transition: background 0.3s ease 0s;
  
  /* common usage */
  transition: all 0.3s ease;
  
  /* multiple properties (comma-separated) */
  transition: background 0.3s, transform 0.2s ease-out;
  
  /* list the same duration on many properties */
  transition: 0.3s;
}

.btn:hover {
  background: darkblue;
  transform: scale(1.05);
}

Funciones de tiempo

Las funciones de tiempo controlan la aceleración. ease (por defecto) es suave. ease-out es la que se siente más responsiva en UI (inicio rápido, final lento). linear se siente antinatural en la mayoría de los movimientos. cubic-bezier(x1,y1,x2,y2) te permite crear curvas personalizadas — valores fuera de 0-1 en el eje y crean sobrepaso/rebote. steps(n) crea saltos discretos, útil para animaciones de sprite-sheet.

css3
.ease { transition: all 0.3s ease; }              /* default, smooth start/end */
.linear { transition: all 0.3s linear; }          /* constant speed */
.ease-in { transition: all 0.3s ease-in; }        /* slow start */
.ease-out { transition: all 0.3s ease-out; }      /* slow end (feels responsive) */
.ease-in-out { transition: all 0.3s ease-in-out; }/* slow both ends */

/* cubic-bezier: custom curve (P1x P1y P2x P2y) */
.custom { transition: all 0.3s cubic-bezier(0.68, -0.55, 0.27, 1.55); } /* overshoot */

/* steps: jump in increments */
.steps { transition: all 0.3s steps(4, end); }

Transiciones múltiples y escalonadas

Distintas propiedades pueden tener distintas duraciones y retardos — útil para efectos coreografiados donde una propiedad termina antes de que otra empiece. transition-delay crea entradas escalonadas en listas; combínalo con nth-child para retrasar cada ítem progresivamente. Los retardos también funcionan en las salidas, pero cuidado: si el usuario retira el cursor a mitad del retardo, la entrada puede dar un salto brusco.

css3
.card {
  /* different durations per property */
  transition: transform 0.2s ease-out, box-shadow 0.4s ease;
  
  /* delay creates staggered effect */
  transition: background 0.3s, color 0.3s 0.1s; /* color starts after 0.1s */
}

.card:hover {
  transform: translateY(-4px);
  box-shadow: 0 10px 30px rgba(0,0,0,0.2);
  background: #f5f5f5;
}

/* stagger multiple elements via transition-delay */
.item:nth-child(1) { transition-delay: 0s; }
.item:nth-child(2) { transition-delay: 0.1s; }
.item:nth-child(3) { transition-delay: 0.2s; }

Propiedades transicionables

Algunas propiedades transicionan con suavidad; otras causan tirones. Las estrellas aceleradas por GPU son transform, opacity y filter. Los colores y box-shadow están bien (disparan paint, no layout). Evita transicionar width, height, margin, top, left — fuerzan el recálculo del layout en cada fotograma. Para animar un cambio de tamaño, usa transform: scale() en su lugar.

css3
/* WELL-SUPPORTED & performant */
.good {
  transition: transform 0.3s, opacity 0.3s, filter 0.3s;
}

/* OK but may trigger paint */
.okay {
  transition: background-color 0.3s, color 0.3s, border-color 0.3s;
  transition: box-shadow 0.3s;
}

/* AVOID: triggers layout (reflow) - janky */
.bad {
  transition: width 0.3s, height 0.3s, margin 0.3s, top 0.3s, left 0.3s;
}

/* if you must animate size, use transform: scale() instead */
.smooth-resize { transition: transform 0.3s; }

Disparadores de transiciones

Las transiciones se disparan ante cualquier cambio de propiedad: estados de pseudo-clase (:hover, :focus, :checked), cambios de clase (añadida/eliminada por JS) y cambios de media query. Interpolan suavemente entre el valor antiguo y el nuevo. Las transiciones solo corren hacia el nuevo estado — ambas direcciones (entrada/salida) se animan. Para movimientos más complejos, en bucle o de varios pasos, usa animaciones @keyframes.

css3
/* hover trigger */
.btn { transition: all 0.3s; }
.btn:hover { transform: scale(1.1); }

/* focus trigger (accessibility-friendly) */
.input { transition: border-color 0.2s; }
.input:focus { border-color: blue; }

/* class change via JavaScript */
.modal { transition: opacity 0.3s; opacity: 0; }
.modal.open { opacity: 1; }

/* media query trigger */
.box { transition: width 0.3s; width: 100%; }
@media (min-width: 768px) { .box { width: 50%; } }

/* CSS state triggers (:checked) */
.toggle:checked + .menu { transition: max-height 0.3s; max-height: 500px; }
11

Animaciones

@keyframes

@keyframes define la secuencia de una animación. Las paradas pueden ser porcentajes (0%, 50%, 100%) o from/to (equivalentes a 0%/100%). Las propiedades no listadas en una parada interpolan entre las paradas definidas. Solo funcionan las propiedades animables (transform, opacity, colores) — display, position, etc. no. Define @keyframes una vez y reutilízalos en muchos elementos.

css3
@keyframes bounce {
  0%   { transform: translateY(0); }
  50%  { transform: translateY(-30px); }
  100% { transform: translateY(0); }
}

/* from/to shorthand (2-stop) */
@keyframes fadeIn {
  from { opacity: 0; }
  to   { opacity: 1; }
}

/* multiple properties at each stop */
@keyframes pulse {
  0%   { opacity: 1; transform: scale(1); }
  50%  { opacity: 0.5; transform: scale(1.1); }
  100% { opacity: 1; transform: scale(1); }
}

Forma corta animation

La forma corta animation agrupa 8 propiedades en este orden: nombre duración función-tiempo retardo contador-iteración dirección fill-mode estado-reproducción. Como mínimo necesitas nombre y duración. Ojo: la ambigüedad de un valor de tiempo sin más — el primer tiempo es la duración, el segundo el retardo. Por legibilidad en producción, prefiere las propiedades largas o una forma corta parcial.

css3
.bouncing {
  /* longhand */
  animation-name: bounce;
  animation-duration: 1s;
  animation-timing-function: ease-in-out;
  animation-delay: 0s;
  animation-iteration-count: infinite;
  animation-direction: alternate;
  animation-fill-mode: both;
  animation-play-state: running;
  
  /* shorthand: name duration timing delay count direction fill-mode play-state */
  animation: bounce 1s ease-in-out 0s infinite alternate both running;
  
  /* minimal: name + duration */
  animation: bounce 1s;
}

Iteración y dirección

animation-iteration-count controla la repetición — infinite repite para siempre, los valores fraccionarios reproducen ciclos parciales. animation-direction: alternate reproduce la animación hacia adelante y luego hacia atrás en la siguiente iteración, creando un rebote continuo. reverse reproduce hacia atrás y alternate-reverse empieza hacia atrás. Alternate es esencial para movimientos de ping-pong como pulsaciones o efectos de respiración.

css3
/* iteration-count: how many times to play */
.once { animation-iteration-count: 1; }    /* default */
.thrice { animation-iteration-count: 3; }
.forever { animation-iteration-count: infinite; }
.fractional { animation-iteration-count: 0.5; } /* half a play */

/* direction */
.normal { animation-direction: normal; }       /* 0% -> 100% */
.reverse { animation-direction: reverse; }     /* 100% -> 0% */
.alternate { animation-direction: alternate; } /* forward, then backward */
.alternate-rev { animation-direction: alternate-reverse; }

Fill mode de la animación

animation-fill-mode controla los estilos antes y después de que la animación se ejecute. none (por defecto) vuelve a los estilos normales del elemento. forwards mantiene el estado del último keyframe tras terminar — esencial en animaciones de entrada para que los elementos no salten de vuelta. backwards aplica el primer keyframe durante el retardo. both cubre ambos casos. Usa forwards o both para entradas de una sola vez.

css3
@keyframes slideIn {
  from { transform: translateX(-100%); }
  to   { transform: translateX(0); }
}

/* none (default): reverts to original styles before/after */
.none { animation: slideIn 1s; }

/* forwards: holds the final (to) state after finishing */
.forwards { animation: slideIn 1s forwards; }

/* backwards: applies the (from) state during delay */
.backwards { animation: slideIn 1s 0.5s backwards; }

/* both: applies from during delay AND holds to after */
.both { animation: slideIn 1s 0.5s both; }

Estado de reproducción y pausa

animation-play-state: paused congela una animación en su fotograma actual; running la reanuda. Es la forma más limpia de pausar al pasar el ratón o mediante una clase alternada por JS — la animación recuerda su posición en lugar de reiniciar. Por rendimiento, pausa las animaciones de los elementos que salen de la vista con IntersectionObserver. Combínalo con media queries de reduced-motion por accesibilidad.

css3
.anim { animation: spin 2s linear infinite; }

/* pause on hover */
.anim:hover { animation-play-state: paused; }

/* pause via class (JS toggle) */
.anim.paused { animation-play-state: paused; }

/* useful for performance: pause off-screen animations */
.offscreen { animation-play-state: paused; }

/* resume */
.resumed { animation-play-state: running; }
12

Media queries

Sintaxis básica

Las media queries aplican estilos condicionalmente. (min-width: 768px) es mobile-first — se aplica en pantallas de 768px en adelante. Combina con and (ambas deben cumplirse), comas (OR) y not (negación). El enfoque mobile-first (min-width) es el preferido: escribe los estilos base para pantallas pequeñas y mejora para las mayores. Así el CSS de pantallas pequeñas se mantiene ligero.

css3
/* apply styles when viewport is at least 768px wide */
@media (min-width: 768px) {
  .grid { grid-template-columns: repeat(2, 1fr); }
}

/* combine conditions with and */
@media (min-width: 768px) and (max-width: 1024px) {
  .box { padding: 20px; }
}

/* list of queries (OR) */
@media (max-width: 600px), (min-width: 1200px) {
  .text { font-size: 14px; }
}

/* negate with not */
@media not print {
  .screen-only { display: block; }
}

Breakpoints de ancho min/max

Los breakpoints deberían basarse en el contenido, no en dispositivos concretos, pero los rangos comunes funcionan bien: 640px (tablet), 1024px (escritorio), 1280px (grande). Mobile-first significa usar min-width y escribir los estilos móviles como base. La sintaxis de rango más nueva (width >= 768px) es más legible y está soportada en cualquier navegador moderno, reemplazando las combinaciones min/max verbosas.

css3
/* common breakpoints (mobile-first) */
/* base styles (mobile) */
.container { padding: 16px; }

@media (min-width: 640px)  { /* small tablets */ 
  .container { padding: 24px; }
}
@media (min-width: 1024px) { /* desktops */
  .container { padding: 32px; max-width: 1200px; margin: 0 auto; }
}
@media (min-width: 1280px) { /* large screens */
  .container { max-width: 1400px; }
}

/* range syntax (newer, cleaner) */
@media (width >= 768px) and (width <= 1024px) {
  .box { padding: 20px; }
}

Orientación y relación de aspecto

Más allá del ancho, las media queries pueden apuntar a la orientación (portrait/landscape), aspect-ratio, capacidad de hover y tipo de puntero. @media (hover: hover) garantiza que los estilos hover solo se apliquen en dispositivos con puntero real (evitando el hover pegajoso en táctil). (pointer: coarse) apunta a dispositivos táctiles — perfecto para agrandar los objetivos de toque. Estas características permiten interfaces verdaderamente adecuadas a cada dispositivo.

css3
/* portrait vs landscape */
@media (orientation: portrait) {
  .grid { grid-template-columns: 1fr; }
}
@media (orientation: landscape) {
  .grid { grid-template-columns: 1fr 1fr; }
}

/* aspect ratio */
@media (min-aspect-ratio: 16/9) {
  .video { width: 100%; height: auto; }
}

/* hover capability: devices that support hover */
@media (hover: hover) {
  .btn:hover { background: darkblue; }
}

/* pointer: fine (mouse) vs coarse (touch) */
@media (pointer: coarse) {
  .btn { padding: 16px 32px; } /* bigger tap targets */
}

Estilos de impresión

Las media queries de impresión estilizan cómo se ven las páginas al imprimir. Oculta navegación, anuncios y elementos interactivos; expande el contenido a ancho completo; fuerza negro sobre blanco por eficiencia de tinta. break-inside: avoid evita que los elementos se partan entre páginas, y break-before: page fuerza saltos de página. El truco ::after en los enlaces revela las URLs al imprimir — inestimable para artículos imprimibles.

css3
@media print {
  /* hide non-essential UI */
  .nav, .sidebar, .ads, .comments { display: none; }
  
  /* expand main content */
  .main { width: 100%; margin: 0; }
  
  /* force black text on white */
  body { color: black; background: white; }
  
  /* avoid breaking inside elements */
  h1, h2, img, table { break-inside: avoid; }
  
  /* page breaks before sections */
  h1 { break-before: page; }
  
  /* show URLs after links */
  a[href]::after { content: " (" attr(href) ")"; }
}

prefers-reduced-motion y color-scheme

prefers-reduced-motion es una característica de accesibilidad crítica — los usuarios con trastornos vestibulares necesitan el movimiento minimizado. Ofrece siempre un respaldo de movimiento reducido que desactive o acorte las animaciones. prefers-color-scheme permite adaptarse automáticamente al tema del sistema operativo del usuario. Para el modo oscuro, considera también contraste, imágenes y sombras que funcionen sobre fondos oscuros.

css3
/* respect users who prefer less motion */
@media (prefers-reduced-motion: reduce) {
  *, *::before, *::after {
    animation-duration: 0.01ms !important;
    animation-iteration-count: 1 !important;
    transition-duration: 0.01ms !important;
    scroll-behavior: auto !important;
  }
}

/* light/dark mode */
@media (prefers-color-scheme: dark) {
  body { background: #1a1a1a; color: #eee; }
  .card { background: #2a2a2a; }
}

@media (prefers-color-scheme: light) {
  body { background: white; color: #333; }
}
13

Diseño responsivo

Tipografía fluida con clamp()

clamp(min, preferido, max) crea valores que escalan fluidamente entre límites — perfecto para tipografía y espaciado que se adaptan sin media queries. El valor preferido suele ser una expresión basada en vw. Esto elimina muchos breakpoints. Emparéjalo con rem por accesibilidad (el usuario aún puede escalar el font-size raíz). La tipografía fluida mejora el rendimiento percibido y la legibilidad en cualquier dispositivo.

css3
/* clamp(min, preferred, max) - fluid between bounds */
h1 {
  /* scales from 1.5rem to 3rem as viewport grows */
  font-size: clamp(1.5rem, 5vw, 3rem);
}

p {
  /* readable body text on any screen */
  font-size: clamp(1rem, 2.5vw, 1.25rem);
}

/* fluid spacing */
.section {
  padding: clamp(1rem, 4vw, 3rem);
}

/* fluid container width */
.container {
  width: clamp(280px, 90vw, 1200px);
  margin: 0 auto;
}

Enfoque mobile-first

Mobile-first significa escribir los estilos de pantallas pequeñas como base y luego usar media queries de min-width para mejorar en pantallas mayores. Esto produce un CSS más ligero (el móvil descarga solo lo que necesita) y fuerza una mentalidad priorizada por contenido. Desktop-first (max-width) obliga a los móviles a descargar y sobrescribir estilos de escritorio — más lento y difícil de mantener.

css3
/* base = mobile styles (no media query) */
.card {
  width: 100%;
  padding: 12px;
  font-size: 14px;
}

/* progressively enhance for larger screens */
@media (min-width: 640px) {
  .card { width: 50%; padding: 16px; }
}

@media (min-width: 1024px) {
  .card { width: 33.33%; padding: 24px; font-size: 16px; }
}

/* AVOID desktop-first (forces mobile to override) */
/* @media (max-width: 640px) { ... } */

Container queries

Las container queries son un antes y un después: permiten que los componentes respondan al tamaño de su padre en lugar del viewport. Una tarjeta puede adaptar su layout tanto en una sidebar estrecha como en un área principal ancha — verdadera responsividad a nivel de componente. container-type: inline-size consulta el ancho (el más eficiente). Nombra los contenedores para apuntar a ellos específicamente, o usa consultas sin nombre para el ancestro más cercano.

css3
/* make an element a query container */
.sidebar {
  container-type: inline-size;
  container-name: sidebar;
}

/* styles based on the container's size, not the viewport */
@container sidebar (min-width: 400px) {
  .card {
    grid-template-columns: 1fr 1fr;
  }
}

/* inline-size = width only (most common, performant) */
/* size = both dimensions (more expensive) */

/* unnamed container query (uses nearest ancestor) */
.card-wrap { container-type: inline-size; }
@container (min-width: 500px) {
  .card { flex-direction: row; }
}

Unidades de viewport

vh/vw son porcentajes del viewport. El problema: 100vh en móvil cambia según la barra de direcciones se muestra/oculta, causando tirones. Las unidades más nuevas svh/lvh/dvh lo corrigen — dvh se actualiza dinámicamente, svh usa el valor estable más pequeño. vmin/vmax son la dimensión del viewport menor/mayor — genial para elementos cuadrados que escalan. Emparéja siempre los tamaños de fuente en vw con un suelo en rem/px mediante calc o clamp.

css3
.hero {
  height: 100vh;        /* full viewport height */
  /* small viewport units: account for mobile browser chrome */
  height: 100svh;       /* smallest possible viewport (stable) */
  height: 100lvh;       /* largest possible viewport */
  height: 100dvh;       /* dynamic - updates as chrome shows/hides */
}

.full-width { width: 100vw; }
.responsive-font { font-size: 5vw; }

/* vmin/vmax: smaller/larger of width or height */
.square { width: 50vmin; height: 50vmin; }
.banner { height: 30vmax; }

/* combining with calc for safety */
.hero-text { font-size: calc(16px + 2vw); }

aspect-ratio

aspect-ratio mantiene una relación ancho:alto automáticamente — adiós a los hacks de padding-top para vídeo responsivo. La altura del elemento se deriva de su ancho (o viceversa). Combinado con object-fit: cover en las imágenes, evita el salto de layout al cargar. Es la forma más limpia de reservar espacio para medios y evitar el desplazamiento acumulativo del layout (CLS) — un Core Web Vital.

css3
/* maintain a 16:9 ratio regardless of width */
.video {
  aspect-ratio: 16 / 9;
  width: 100%;
}

/* square avatar */
.avatar {
  aspect-ratio: 1;
  width: 80px;
  border-radius: 50%;
}

/* golden ratio card */
.card {
  aspect-ratio: 1.618;
}

/* combined with object-fit for responsive images */
.thumb {
  aspect-ratio: 4 / 3;
  width: 100%;
  object-fit: cover;
}
14

Propiedades personalizadas (variables)

Definir y usar variables

Las propiedades personalizadas de CSS (variables) se declaran con --name y se usan con var(--name). Defínelas en :root para acceso global, o acótalas a cualquier elemento. A diferencia de las variables de preprocesadores, están vivas: cambiar una variable actualiza cada uno de sus usos en tiempo real, y cascadan y heredan. var() acepta un respaldo como segundo argumento, usado cuando la variable no está definida.

css3
:root {
  --primary: #3490dc;
  --spacing: 16px;
  --max-width: 1200px;
}

.button {
  background: var(--primary);
  padding: var(--spacing);
  /* with fallback value (used if --primary undefined) */
  color: var(--text-color, #333);
}

/* override in a specific scope */
.dark-theme {
  --primary: #5a9fee;
}

Tematización y modo oscuro

Las propiedades personalizadas hacen trivial la tematización: define variables semánticas (--bg, --text, --primary) y sobrescríbelas en un selector [data-theme]. Alternar el atributo data-theme en <html> intercambia el tema completo al instante — sin hojas de estilo duplicadas. Combínalo con prefers-color-scheme para un modo oscuro automático que respete la anulación manual del usuario. Esta es la forma moderna y eficiente de tematizar.

css3
:root {
  --bg: #ffffff;
  --text: #1a1a1a;
  --primary: #3490dc;
}

[data-theme="dark"] {
  --bg: #1a1a1a;
  --text: #ffffff;
  --primary: #5a9fee;
}

body {
  background: var(--bg);
  color: var(--text);
}

/* auto dark mode via media query */
@media (prefers-color-scheme: dark) {
  :root:not([data-theme="light"]) {
    --bg: #1a1a1a;
    --text: #ffffff;
  }
}

Cascada y herencia

Las propiedades personalizadas cascadan y heredan como el CSS normal. Una variable definida en .card está disponible para .card y sus descendientes — pero no para los hermanos. Cada elemento lee el valor calculado de la variable en su propio ámbito. @property (más nuevo) permite declarar variables tipadas con una sintaxis, valor inicial y flag de herencia — habilitando transiciones y animaciones suaves de propiedades personalizadas.

css3
:root { --color: blue; }       /* global */
.card { --color: green; }      /* scoped to .card */
.card .inner { color: var(--color); } /* green - inherits from .card */

/* variables inherit like other properties */
.parent { --size: 20px; }
.child { font-size: var(--size); } /* 20px via inheritance */

/* but: each element reads its own computed value */
.a { --x: 10px; }
.b { /* --x is NOT defined here, even if .a is sibling */ }

/* @property: typed variables with initial value */
@property --angle {
  syntax: "<angle>";
  inherits: false;
  initial-value: 0deg;
}

Interacción con JavaScript

Las variables CSS son totalmente accesibles desde JavaScript. Lee con getComputedStyle(el).getPropertyValue('--name') (devuelve una cadena, a menudo con un espacio inicial — recórtalo). Escribe con el.style.setProperty('--name', value). Esto convierte a las propiedades personalizadas en un potente puente de JS a CSS: actualiza una variable en JS y el CSS reacciona al instante — perfecto para efectos guiados por scroll, tematización y layouts dinámicos.

css3
/* read a variable */
const styles = getComputedStyle(document.documentElement);
const primary = styles.getPropertyValue("--primary"); /* "#3490dc" */

/* set a variable globally */
document.documentElement.style.setProperty("--primary", "#ff0000");

/* set on a specific element */
el.style.setProperty("--spacing", "24px");

/* inline style with variable */
<div style="--rotate: 45deg"></div>

/* useful pattern: expose JS values to CSS */
.root { --scroll: 0; }
.box { transform: rotate(calc(var(--scroll) * 1deg)); }

Respaldo y encadenamiento

var() soporta un respaldo como segundo argumento, usado solo cuando la variable no está definida (no cuando es inválida — los valores inválidos hacen que toda la propiedad vuelva a su valor por defecto). Los respaldos pueden encadenarse: var(--a, var(--b, #default)). Es útil para la mejora progresiva y la integración de componentes de terceros. Usa @supports (--x: 0) para detectar soporte, aunque los navegadores modernos actuales ya soportan propiedades personalizadas.

css3
.box {
  /* single fallback */
  color: var(--undefined, #333);
  
  /* chained: try --primary, fall back to --blue, then #00f */
  color: var(--primary, var(--blue, #0000ff));
  
  /* fallback in calc() */
  width: calc(100% - var(--sidebar, 250px));
  
  /* invalid values fall back to inherited/default */
  /* var() itself doesn't fail — the property does */
}

/* feature detection for custom property support */
@supports (--custom: property) {
  :root { --modern: true; }
}
15

Filtros

Funciones de filtro

filter aplica efectos visuales a un elemento. brightness/contrast/saturate aceptan multiplicadores (1 = normal) o porcentajes. hue-rotate desplaza cada tono un ángulo. Varios filtros se encadenan de izquierda a derecha. Uso común: imágenes en escala de grises al pasar el ratón, efectos de foto vintage o atenuar fondos. Los filtros afectan al elemento, su fondo, sus bordes y sus hijos.

css3
.blur { filter: blur(4px); }              /* gaussian blur in px */
.bright { filter: brightness(1.5); }     /* 1 = normal, >1 brighter */
.contrast { filter: contrast(200%); }    /* 100% = normal */
.gray { filter: grayscale(100%); }       /* 0-100% */
.sepia { filter: sepia(80%); }
.hue { filter: hue-rotate(90deg); }      /* rotate hue */
.invert { filter: invert(100%); }        /* invert colors */
.saturate { filter: saturate(2); }       /* 1 = normal */
.opacity { filter: opacity(50%); }

/* combine multiple filters (left-to-right) */
.vintage { filter: sepia(60%) contrast(110%) brightness(90%) saturate(1.2); }

drop-shadow

drop-shadow es el equivalente en filtro de box-shadow — pero sigue la forma alfa real del elemento, no su caja. Esto significa que las sombras se abrazan a los recortes de PNG/SVG y a las formas irregulares. Úsalo para sombras de iconos, logos brillantes o cualquier elemento no rectangular. Se pueden apilar varios drop-shadows. Ojo: puede ser más costoso que box-shadow, así que úsalo con criterio.

css3
/* drop-shadow follows the alpha shape (unlike box-shadow) */
.cutout {
  filter: drop-shadow(4px 4px 8px rgba(0,0,0,0.4));
}

/* shadows on PNG with transparency - hugs the shape */
.logo {
  filter: drop-shadow(0 4px 6px rgba(0,0,0,0.3));
}

/* glow effect on text or SVG */
.icon {
  filter: drop-shadow(0 0 8px rgba(0, 150, 255, 0.8));
}

/* multiple drop-shadows layer */
.deep {
  filter: drop-shadow(0 1px 1px rgba(0,0,0,0.5))
          drop-shadow(0 2px 4px rgba(0,0,0,0.3));
}

backdrop-filter

backdrop-filter aplica un filtro a lo que hay detrás de un elemento — la firma del glassmorphism. Un fondo semitransparente más backdrop-filter: blur() crea el aspecto de cristal esmerilado. Incluye siempre el prefijo -webkit- para Safari. El elemento necesita cierta transparencia en su fondo para que se aprecie el efecto. Combínalo con saturate() para resultados vibrantes, y añade un borde sutil para simular el reflejo del borde.

css3
/* frosted glass effect */
.glass {
  background: rgba(255, 255, 255, 0.2);
  backdrop-filter: blur(10px);
  -webkit-backdrop-filter: blur(10px); /* Safari */
  border: 1px solid rgba(255, 255, 255, 0.3);
}

/* saturate + blur for vivid glass */
.vivid-glass {
  backdrop-filter: blur(16px) saturate(180%);
}

/* dark glass for dark mode */
.dark-glass {
  background: rgba(0, 0, 0, 0.3);
  backdrop-filter: blur(12px);
}

Combinar filtros

Varios filtros se aplican de izquierda a derecha, así que el orden afecta al resultado (escala de grises antes de hue-rotate no tiene nada que rotar, por ejemplo). Los filtros son animables y están acelerados por GPU — geniales para efectos hover. Emparéja filter con mix-blend-mode para mezclar un elemento con su fondo. Para control dinámico, guarda la cadena de filtros en una propiedad personalizada y actualízala vía JS.

css3
/* order matters: each filter feeds the next */
.artsy {
  filter: grayscale(100%) contrast(150%) brightness(110%);
}

/* animate filters smoothly */
img { transition: filter 0.3s; }
img:hover { filter: grayscale(0%) saturate(1.4); }

/* use CSS variables for dynamic filters */
.dynamic { filter: var(--photo-filter, none); }

/* layer with other effects */
.complex {
  filter: blur(1px) brightness(1.1);
  mix-blend-mode: multiply;
  opacity: 0.9;
}

Rendimiento de los filtros

Los filtros están acelerados por GPU pero no son gratis. Los blurs grandes sobre elementos a pantalla completa causan repintados pesados y tirones, especialmente en móvil. Mantén los radios de blur pequeños, limita el área filtrada y aplica will-change: filter antes de disparar animaciones. backdrop-filter es especialmente costoso — úsalo en elementos pequeños de UI, no en secciones completas. contain: paint aísla el área de repintado para mejor rendimiento.

css3
/* AVOID: large blur on full-screen elements */
.janky { filter: blur(20px); } /* causes repaints */

/* BETTER: pre-blurred image, or limit blur area */
.smooth {
  filter: blur(2px); /* small radius is cheaper */
}

/* backdrop-filter is expensive - use sparingly */
/* contain: paint can limit repaint area */
.contained {
  contain: paint;
  backdrop-filter: blur(10px);
}

/* will-change prepares the GPU layer */
.prepared {
  will-change: filter;
  filter: blur(4px);
}
16

Pseudo-elementos

::before y ::after

::before y ::after insertan contenido generado antes/después del contenido real de un elemento. La propiedad content es obligatoria (aunque sea una cadena vacía para elementos decorativos). El contenido puede ser texto, Unicode escapado o valores de atributos vía attr(). Estos pseudo-elementos son inline por defecto — fija display: block para decoración tipo caja. Son perfectos para iconos, líneas decorativas, comillas y limpiar floats.

css3
.quote::before { content: "\201C"; }  /* opening quote */
.quote::after  { content: "\201D"; }  /* closing quote */

/* icon via Unicode */
.warning::before { content: "\26A0"; margin-right: 6px; }

/* decorative element with content: "" */
.card::after {
  content: "";
  display: block;
  width: 50px; height: 2px;
  background: currentColor;
  margin-top: 12px;
}

/* content can use attributes */
a[href^="http"]::after {
  content: " (" attr(href) ")";
  font-size: 0.8em;
}

::first-letter y ::first-line

::first-letter estiliza el primer carácter — perfecto para capitulares en artículos. ::first-line estiliza la primera línea formateada, que se ajusta dinámicamente al cambiar el ancho del viewport. Ambos solo funcionan en elementos de bloque. Ojo: ::first-letter solo se aplica cuando el primer carácter no va precedido de otro contenido (como imágenes). Son esenciales tipográficos para layouts editoriales.

css3
article p::first-letter {
  font-size: 3em;
  font-weight: bold;
  float: left;
  line-height: 0.8;
  margin-right: 8px;
  /* drop cap effect */
}

article p::first-line {
  text-transform: uppercase;
  letter-spacing: 1px;
  font-weight: bold;
}

/* only works on block-level elements */
/* affects the first formatted line (reflows with width) */

::selection

::selection estiliza la porción de texto que el usuario resalta. Solo aplican unas pocas propiedades: color, background-color, text-shadow y text-decoration. Úsalo para adaptar el color de selección a tu sitio. Aplícalo globalmente con ::selection o acótalo a elementos concretos. El Firefox antiguo necesitaba ::-moz-selection, pero el Firefox moderno soporta el ::selection estándar.

css3
/* style highlighted/selected text */
::selection {
  background: #b3d4fc;
  color: black;
  text-shadow: none;
}

/* scoped to specific elements */
p::selection { background: yellow; }
.highlight::selection { background: gold; color: #333; }

/* note: only a few properties work:
   color, background-color, text-shadow, 
   text-decoration (and its longhands) */

/* firefox historically used ::-moz-selection */

::placeholder y ::marker

::placeholder estiliza el texto del marcador en los inputs del formulario — fija opacity: 1 porque Firefox usa por defecto un marcador translúcido. ::marker estiliza las viñetas o números de los ítems de lista, y soporta un conjunto limitado de propiedades (color, content, font, direction). Puedes reemplazar las viñetas con contenido personalizado (Unicode, contadores). Estos pseudo-elementos ponen el estilo de formularios y listas totalmente bajo control del diseñador.

css3
/* style input placeholder text */
input::placeholder {
  color: #999;
  font-style: italic;
  opacity: 1; /* Firefox applies opacity < 1 by default */
}

/* style list item markers (bullets/numbers) */
ul li::marker {
  color: red;
  font-size: 1.2em;
  content: "\25CF"; /* custom bullet */
}

ol li::marker {
  content: counter(list-item) ". ";
  color: blue;
  font-weight: bold;
}

/* ::marker supports: color, content, font properties,
   direction, unicode-bidi, text-transform, white-space */

Contenido generado y contadores

El contenido generado vía ::before/::after puede incluir valores de counter(), valores de atributos (attr()) o literales de cadena — habilitando numeración, iconos y tooltips solo con CSS, sin DOM extra. counters() produce numeración anidada como '1.2.3'. Los tooltips construidos con attr(data-tooltip) y una transición hover son una alternativa ligera a las librerías JS. Recuerda: el contenido generado no está en el DOM y algunos lectores de pantalla no lo leen — no pongas contenido crítico ahí.

css3
/* counter in generated content */
h2::before {
  content: "Section " counter(section) ": ";
  color: gray;
}

/* attr() reads HTML attributes */
a::after {
  content: attr(data-icon);
}

/* counters() for nested numbering */
ol { counter-reset: item; }
li { display: block; }
li::before {
  content: counters(item, ".") " ";
  counter-increment: item;
}

/* CSS-only tooltip */
.tooltip::after {
  content: attr(data-tooltip);
  position: absolute;
  background: black; color: white;
  padding: 4px 8px;
  opacity: 0; transition: opacity 0.2s;
}
.tooltip:hover::after { opacity: 1; }
17

Contadores

counter-reset y counter-increment

Los contadores CSS permiten numerar elementos sin JavaScript. counter-reset inicializa un contador (por defecto a 0, pero puedes empezar en otro valor). counter-increment lo aumenta (por defecto en 1, pero cualquier entero vale — incluso negativo). Muestra el valor con counter() dentro de content. Los contadores tienen el ámbito del elemento donde se reinician y sus descendientes, habilitando la numeración anidada.

css3
body { counter-reset: section; }   /* initialize to 0 */

h2 {
  counter-increment: section;  /* +1 each h2 */
}

h2::before {
  content: "Section " counter(section) ": ";
}

/* custom increment value */
ol { counter-reset: item; }
li { counter-increment: item 1; }  /* +1 (default) */
li.big { counter-increment: item 2; } /* +2 */

/* reset to a custom starting value */
.start-5 { counter-reset: item 4; } /* next increment = 5 */

Función counter()

counter(nombre) muestra el valor actual de un contador, y counter(nombre, estilo) aplica un estilo de lista: decimal (por defecto), lower/upper-alpha, lower/upper-roman, disc, square y más. Puedes manejar varios contadores en paralelo y combinarlos en content — perfecto para figuras numeradas por capítulo (Figura 3-2). Los valores de los contadores se calculan al renderizar, así que se actualizan automáticamente cuando el DOM cambia.

css3
body { counter-reset: section; }
h2 { counter-increment: section; }
h2::before {
  content: "Chapter " counter(section) ". ";
  color: navy;
}

/* counter style (decimal, lower-alpha, upper-roman, etc.) */
h2::before {
  content: counter(section, upper-roman) ". ";
}

/* multiple counters */
body { counter-reset: section figure; }
h2 { counter-increment: section; }
figcaption { counter-increment: figure; }
figcaption::before {
  content: "Figure " counter(section) "-" counter(figure) ": ";
}

Contadores anidados con counters()

counters(nombre, separador) es la función de contadores anidados: concatena el valor del contador en cada ámbito ancestro, separados por la cadena dada. Esto produce esquemas como '1.2.3' automáticamente — el mismo nombre de contador se reinicia en cada <ol> anidado. Sin counters() (en plural), las listas anidadas compartirían la misma numeración. El separador puede ser cualquier cadena, como '.' o '-'.

css3
ol { counter-reset: item; list-style: none; }
li::before {
  counter-increment: item;
  /* counters() concatenates ancestor counters with separator */
  content: counters(item, ".") " ";
}

/* produces: 1 / 1.1 / 1.2 / 2 / 2.1 / 2.1.1 ... */
<ol>
  <li>Item
    <ol>
      <li>Sub-item</li>
      <li>Sub-item</li>
    </ol>
  </li>
  <li>Item</li>
</ol>

/* custom separator */
li::before { content: counters(item, "-") ": "; }

Estilo de los contadores

Los contadores soportan muchos estilos integrados: decimal, upper-roman, lower-alpha, lower-greek, cjk-decimal y más. @counter-style te permite definir estilos personalizados con un conjunto de símbolos, un sistema (cyclic, additive, extends) y opciones como pad (ceros a la izquierda), prefix/suffix y range. Es genial para listas temáticas, viñetas con emoji o numeración localizada sin JavaScript.

css3
/* built-in styles */
.decimal { content: counter(c, decimal); }
.roman { content: counter(c, upper-roman); }       /* I, II, III */
.alpha { content: counter(c, lower-alpha); }        /* a, b, c */
.greek { content: counter(c, lower-greek); }        /* alpha, beta, gamma */
.cjk { content: counter(c, cjk-decimal); }          /* CJK numerals */

/* @counter-style: define a custom style */
@counter-style thumbs {
  system: cyclic;
  symbols: "\1F44D"; /* thumbs up emoji */
  suffix: " ";
}
.like-list { list-style-type: thumbs; }

/* leading zeros via pad */
@counter-style padded {
  system: extends decimal;
  pad: 3 "0"; /* 001, 002, ... */
}

Patrones prácticos de contadores

Los contadores brillan en indicadores de pasos numerados, índices de contenido y esquemas. Estiliza el ::before con una insignia circular, color y número para crear listas de pasos numeradas sin numeración manual. Edita el DOM y los números se actualizan solos. Advertencia: los valores de los contadores no se leen fácilmente desde JavaScript — son solo de visualización. Para lógica basada en conteos, usa JS o CSS :nth-child.

css3
/* numbered steps */
.steps { counter-reset: step; }
.steps li { counter-increment: step; }
.steps li::before {
  content: counter(step);
  display: inline-block;
  width: 28px; height: 28px;
  border-radius: 50%;
  background: var(--primary);
  color: white;
  text-align: center;
  line-height: 28px;
  margin-right: 10px;
}

/* "you've completed N sections" via counters (limited - 
   counters can't be read by JS easily, use them for display) */
18

Layout multicol

column-count y column-width

El layout multicol (multi-column) fluye el contenido en columnas tipo periódico. column-count fija el número; column-width permite al navegador crear tantas columnas de 250px como quepan (responsivo sin media queries). La forma corta columns acepta número y/o ancho. El multicol es ideal para texto de lectura extensa, pero con cautela: el contenido corto puede causar alturas de columna desiguales.

css3
.article {
  /* fixed number of columns */
  column-count: 3;
  
  /* OR width-based (browser decides count) */
  column-width: 250px;
  
  /* shorthand (count width) */
  columns: 3 250px;
  columns: 3;       /* 3 columns */
  columns: 250px;   /* 250px columns, auto count */
}

/* responsive: width lets columns collapse on small screens */
.fluid { column-width: 200px; } /* 1 column on mobile, more on desktop */

column-gap y column-rule

column-gap fija el espacio entre columnas (ahora también lo usan flexbox y grid). column-rule dibuja una línea divisoria vertical en el hueco — es el equivalente de border para columnas, con la misma forma corta. La regla no ocupa ancho extra; queda centrada en el hueco. Usa un color sutil para delimitar columnas sin resultar intrusivo.

css3
.article {
  column-count: 3;
  column-gap: 30px;          /* space between columns */
  
  /* divider line (like border) */
  column-rule: 1px solid #ddd; /* shorthand */
  column-rule-width: 1px;
  column-rule-style: solid;
  column-rule-color: #ddd;
}

/* rule sits in the gap, doesn't add width */

column-span

column-span: all hace que un elemento se extienda a través de todas las columnas — perfecto para un titular estilo revista que ocupa el ancho completo con columnas fluyendo arriba y abajo. column-span: none (por defecto) mantiene el contenido fluyendo entre columnas. Ten en cuenta que puede causar un reflow significativo y ha tenido soporte inconsistente; pruébalo a fondo. Es más fiable para encabezados entre bloques de columnas.

css3
.article {
  column-count: 3;
}

/* heading spans all columns (like a magazine) */
.article h2 {
  column-span: all;
  /* resets above the heading, columns resume below */
}

/* default: content flows through columns */
.normal { column-span: none; }

/* note: column-span: all can cause reflow and is 
   not supported in older Firefox */

break-inside y saltos de columna

El contenido multicol puede partir elementos de forma fea entre columnas. break-inside: avoid mantiene un elemento (como una tarjeta o figura) intacto dentro de una columna. break-before/break-after: column fuerzan saltos de columna. Las propiedades más antiguas page-break-* funcionan como alias. Un hack común era display: inline-block con width: 100%, pero break-inside: avoid es el enfoque moderno y correcto.

css3
/* prevent an element from splitting across columns */
.card {
  break-inside: avoid;        /* modern */
  -webkit-column-break-inside: avoid; /* old webkit */
  page-break-inside: avoid;   /* old */
  display: inline-block;      /* hack for older browsers */
  width: 100%;
}

/* control where columns break */
h2 { break-after: column; }   /* force new column after */
h3 { break-before: column; }  /* force new column before */
p  { break-inside: avoid; }   /* keep paragraph together */

column-fill y balanceo

column-fill controla cómo se distribuye el contenido entre columnas. balance (por defecto) iguala las alturas para que las columnas terminen aproximadamente alineadas — visualmente prolijo. auto llena por completo la primera columna antes de pasar a la siguiente, requiriendo una altura fija; coincide con el comportamiento impreso. Las columnas equilibradas son más agradables para uso general; auto es mejor cuando el contenido debe fluir estrictamente de arriba abajo.

css3
.article {
  column-count: 3;
  
  /* balance: equalize column heights (default in most browsers) */
  column-fill: balance;
  
  /* auto: fill first column fully, then next (needs height) */
  column-fill: auto;
  height: 500px; /* required for auto */
}

/* balanced columns look neat but can split awkwardly;
   auto is more like print, fills top-to-bottom */
19

Interfaz de usuario

Outline y accesibilidad

Los indicadores de foco visibles son un requisito de accesibilidad. :focus-visible muestra el contorno solo para usuarios de teclado (no de ratón), la mejor práctica para el estilo de foco. Nunca fjes outline: none sin un reemplazo (como un anillo de box-shadow). outline-offset añade un respiro entre el elemento y el contorno. Los navegadores modernos soportan contornos redondeados vía border-radius que afecta a la forma del outline.

css3
/* visible focus ring for keyboard users */
button:focus-visible {
  outline: 2px solid #0066cc;
  outline-offset: 2px;
}

/* never outline: none without a replacement */
/* custom focus ring via box-shadow */
button:focus {
  outline: none;
  box-shadow: 0 0 0 3px rgba(0, 102, 204, 0.5);
}

/* outline shorthand */
.outlined { outline: 2px dashed red; outline-offset: 4px; }

/* thick rounded outline (modern browsers) */
button:focus-visible {
  outline: 3px solid blue;
  outline-offset: 2px;
  border-radius: 4px;
}

resize

resize controla si el usuario puede redimensionar arrastrando un elemento. textarea es redimensionable por defecto; fjar resize: none lo desactiva. vertical/horizontal/both acotan la dirección. Para que resize funcione, el elemento debe tener un overflow distinto de visible (fija overflow: auto o hidden). Útil para textareas, editores de código o cualquier panel ajustable por el usuario.

css3
textarea {
  /* allow vertical resize only (default for textarea) */
  resize: vertical;
  
  /* allow both axes */
  resize: both;
  
  /* horizontal only */
  resize: horizontal;
  
  /* disable resizing */
  .locked { resize: none; }
  
  /* default: inline/block elements can't be resized;
     textarea default is both in most browsers */
}

/* note: resize only works on overflow != visible */

caret-color y user-select

caret-color fija el color del cursor parpadeante en elementos editables — un detalle pequeño pero agradable en formularios con marca. user-select controla si el texto puede seleccionarse: none lo desactiva (para controles de UI), all selecciona el elemento entero al hacer clic (bueno para bloques de código o correos) y contain mantiene la selección dentro del elemento. Evita user-select: none en el body — perjudica la accesibilidad.

css3
/* color of the text cursor in inputs */
input, textarea {
  caret-color: #0066cc;  /* default: current color */
}

/* custom thick caret (limited support) */
input { caret-color: red; }

/* control text selection by the user */
.no-select { user-select: none; }        /* disable selection */
.select-all { user-select: all; }        /* select whole element on click */
.select-text { user-select: text; }      /* normal text selection */
.select-contain { user-select: contain; } /* selection stays within */

/* email addresses, code blocks often user-select: all */

appearance y estilo de formularios

appearance: none elimina el estilo nativo del sistema operativo de los controles del formulario, dejándote estilizarlos por completo con CSS — esencial para un diseño de formularios consistente entre navegadores. Tras quitar la flecha nativa del select, añade un background-image personalizado. Los checkboxes personalizados usan appearance: none más :checked para el estado. Prefija siempre con -webkit-/-moz- para soporte completo. Pruébalo a fondo entre navegadores — algunos controles (date, color) siguen siendo difíciles de restilizar por completo.

css3
/* remove native widget styling */
input, select, button {
  -webkit-appearance: none;
  -moz-appearance: none;
  appearance: none;
}

/* custom select arrow (after removing native) */
select {
  background-image: url("arrow.svg");
  background-repeat: no-repeat;
  background-position: right 10px center;
  padding-right: 30px;
}

/* style checkbox/radio with appearance: none */
input[type="checkbox"] {
  appearance: none;
  width: 20px; height: 20px;
  border: 2px solid #999;
  border-radius: 4px;
}
input[type="checkbox"]:checked {
  background: var(--primary);
  border-color: var(--primary);
}

scroll-behavior y scrollbar

scroll-behavior: smooth en <html> hace que los clics en enlaces de ancla se animen hacia el objetivo en lugar de saltar — emparéjalo con prefers-reduced-motion para desactivarlo en usuarios sensibles. Barras de scroll personalizadas: las propiedades estándar scrollbar-width/scrollbar-color funcionan en Firefox y Chrome moderno; los pseudo-elementos ::-webkit-scrollbar dan control más fino en WebKit/Blink. Unas barras de scroll personalizadas sutiles pulen la UX de las áreas desplazables.

css3
/* smooth scrolling for anchor links */
html { scroll-behavior: smooth; }

/* respect reduced motion */
@media (prefers-reduced-motion: reduce) {
  html { scroll-behavior: auto; }
}

/* custom scrollbar (WebKit) */
.scroll-area::-webkit-scrollbar { width: 8px; }
.scroll-area::-webkit-scrollbar-track { background: #f1f1f1; }
.scroll-area::-webkit-scrollbar-thumb { background: #888; border-radius: 4px; }
.scroll-area::-webkit-scrollbar-thumb:hover { background: #555; }

/* standard scrollbar-color (Firefox + spec) */
.scroll-area {
  scrollbar-width: thin;
  scrollbar-color: #888 #f1f1f1;
}
20

Características avanzadas y modernas

Scroll Snap

Scroll Snap crea carruseles o scroll de página completa sin JavaScript. scroll-snap-type: x/y + mandatory/proximity controla el eje y la rigidez. Los hijos con scroll-snap-align se ajustan a start/center/end. mandatory fuerza el ajuste (bueno para secciones de página completa); proximity solo ajusta cuando está cerca (más suave, para galerías de imágenes). Combínalo con scroll-margin para desplazar los puntos de ajuste bajo encabezados pegajosos.

css3
.gallery {
  scroll-snap-type: x mandatory;  /* snap horizontally, must snap */
  overflow-x: auto;
  display: flex;
}

.gallery > img {
  scroll-snap-align: center;   /* start | center | end */
  scroll-snap-stop: always;    /* can't skip snaps */
  flex: 0 0 80%;
}

/* vertical full-page snap */
.pages {
  scroll-snap-type: y mandatory;
  height: 100vh;
  overflow-y: scroll;
}
.page { scroll-snap-align: start; height: 100vh; }

/* proximity: only snaps when close (gentler) */
.soft { scroll-snap-type: y proximity; }

object-fit y object-position

object-fit controla cómo un <img> o <video> llena su caja — el equivalente de background-size para medios. cover llena la caja y recorta el exceso; contain encaja el medio entero con posible espacio vacío; fill estira (distorsiona). object-position fija el punto focal — útil cuando cover recorta partes importantes de una imagen. Esto elimina la necesidad de hacks de background-image para medios responsivos.

css3
/* cover: fill box, crop overflow (like background-size: cover) */
.avatar img {
  width: 100px; height: 100px;
  object-fit: cover;        /* cover | contain | fill | none | scale-down */
  object-position: center;  /* position the focal point */
  border-radius: 50%;
}

/* contain: whole image visible, may letterbox */
.preview img {
  width: 300px; height: 200px;
  object-fit: contain;
  background: #eee;
}

/* object-position shifts the visible area */
.banner img {
  width: 100%; height: 300px;
  object-fit: cover;
  object-position: top;  /* show top of image */
}

will-change

will-change insinúa al navegador que una propiedad cambiará pronto, dejándolo preasignar capas de GPU y optimizar. Aplícalo justo antes de una animación y retíralo después — el uso permanente en muchos elementos desperdicia memoria y puede perjudicar el rendimiento. Lista solo propiedades que realmente se animen (transform, opacity, filter). El abuso desencadena el efecto contrario al buscado, así que úsalo con moderación e intención.

css3
/* hint that an element will animate transform */
.card { will-change: transform; }

/* remove when not needed (frees GPU memory) */
.card.idle { will-change: auto; }

/* multiple properties */
.complex { will-change: transform, opacity; }

/* AVOID: permanent will-change on many elements */
/* .all { will-change: transform, opacity, top, left; } */ /* bad */

/* apply just before animation, remove after */
.prepare { will-change: transform; }
/* JS: el.classList.add('prepare'); 
   setTimeout(() => el.classList.remove('prepare'), 1000); */

contain

contain le dice al navegador que un elemento es independiente del resto de la página, habilitando grandes optimizaciones de rendimiento — los cambios dentro de un elemento con contain no disparan recálculos fuera de él. layout, paint, style y size son los tipos de aislamiento. strict (los cuatro, incluido size) es el más fuerte. Aplica contain a widgets repetidos, ítems de lista o anuncios para limitar el coste de reflow/repaint. size exige dimensiones explícitas.

css3
/* isolate an element's layout/paint/style from the rest */
.widget {
  contain: layout paint style;  /* or: strict, content */
  
  /* size: the element's size is independent of its children */
  contain: size;  /* needs explicit dimensions */
}

/* layout: changes inside don't affect outside layout */
/* paint: children don't render outside the box (clipped) */
/* style: counters and quotes are scoped */
/* size: element ignores children for sizing */

/* full isolation */
.isolated { contain: strict; } /* = size layout paint style */
.content-isolated { contain: content; } /* = layout paint style */

/* useful for performance on complex widgets, lists, ads */

aspect-ratio y gap universal

aspect-ratio mantiene una relación ancho:alto en cualquier elemento, evitando saltos de layout al cargar los medios. gap (y sus propiedades largas row-gap/column-gap) es la herramienta moderna de espaciado, funciona en flexbox, grid y multicol — eliminando los hacks de .item + margin + :last-child. Ambas características están soportadas universalmente en navegadores modernos y juntas resuelven dos de los dolores de cabeza de CSS más comunes: mantener las proporciones de los medios y espaciar los ítems limpiamente.

css3
/* aspect-ratio works on any element */
.video-wrap {
  aspect-ratio: 16 / 9;
  background: black;
}

/* gap works in flex, grid, and multi-column */
.flex { display: flex; gap: 16px; }
.grid { display: grid; gap: 16px; }
.cols { column-count: 3; column-gap: 16px; }

/* row-gap / column-gap longhands */
.layout {
  display: grid;
  row-gap: 24px;
  column-gap: 16px;
}

/* gap replaced margin-based spacing hacks */
/* (no more .item:last-child { margin-right: 0 }) */

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.