Skip to content

CSS3 Folha de referência

Evolução mais recente do CSS, com módulos para estilização, layout e animação.

01

Seletores

Seletores de atributo e pseudo-classes

O CSS3 introduziu seletores de atributo e pseudo-classes poderosos. ^= casa o prefixo, $= casa o sufixo, *= casa uma substring. nth-child permite listras zebra sem 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-classes estruturais

Pseudo-classes estruturais selecionam elementos pela posição no DOM. :first-child / :last-child miram as pontas. nth-child(an+b) suporta fórmulas: 2n é par, 2n+1 é ímpar, 3n é a cada três. :nth-of-type conta apenas irmãos do mesmo tipo de elemento. :empty casa elementos sem filhos.

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 e :has

:is() e :where() agrupam seletores para economizar código. A diferença: :is() assume a maior especificidade dos seus argumentos, enquanto :where() sempre tem especificidade zero — ideal para estilos base fáceis de sobrescrever. :has() é o aguardado seletor pai/relacional, permitindo estilizar um elemento com base nos seus descendentes.

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; }

Negação e pseudo-classes de formulário

:not() nega um seletor e agora aceita uma lista. Pseudo-classes de formulário (:required, :valid, :invalid, :checked, :placeholder-shown, :in-range) permitem estilizar com base no estado do input sem JavaScript — ótimo para feedback de validação inline e estilização personalizada 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; }

Especificidade e cascata

A especificidade decide qual regra se aplica quando seletores conflitam. Conte IDs, classes e elementos como (a,b,c). !important sobrescreve a cascata mas quebra a manutenção — evite. Em empate de especificidade, a regra posterior na ordem do código vence. O DevTools mostra a cascata 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

Box model

box-sizing

box-sizing: border-box inclui padding e borda dentro da width/height declarada, tornando o dimensionamento previsível. content-box (padrão) os adiciona por cima. Aplicar border-box globalmente é o reset CSS mais importante — elimina as maiores dores de cabeça de cálculo de layout.

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;
}

Margin e padding

Padding fica dentro da borda (herda o fundo); margin fica fora (transparente). Margens verticais entre elementos block adjacentes colapsam para o maior valor — margens horizontais nunca colapsam. margin: 0 auto centraliza um elemento block com largura definida. Margens negativas podem puxar conteúdo, mas use com parcimônia.

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

Sintaxe do box-shadow: offset-x offset-y blur-radius spread-radius cor. Offsets positivos empurram a sombra para a direita/baixo. inset cria uma sombra interna. Múltiplas sombras se empilham, com a primeira por cima. Use rgba para sombras translúcidas e naturais. Sombras duras (blur zero) criam uma estética plana e marcante.

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 remove o elemento do layout (sem espaço reservado). Elementos block ocupam a largura total e empilham verticalmente; elementos inline fluem com o texto e ignoram width/height. inline-block combina fluxo inline com dimensionamento de bloco. flow-root limpa floats sem hacks de clearfix. contents faz a caixa desaparecer mantendo os filhos no 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 como o conteúdo que excede a caixa é tratado. visible (padrão) deixa vazar; hidden corta; auto adiciona barras de rolagem quando necessário; scroll sempre as mostra. clip (mais novo) é como hidden, mas impede qualquer rolagem, até via JS. Use overflow-y/x para controlar os eixos de forma independente. Definir overflow como algo diferente de visible cria um novo contexto de formatação.

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

Container flex

display: flex torna um elemento um container flex. justify-content alinha os itens ao longo do eixo principal (horizontal em row); align-items alinha no eixo transversal. flex-wrap permite que os itens quebrem para novas linhas. gap substitui o hack de espaçamento baseado em margin. Flexbox brilha em layouts unidimensionais (linhas ou colunas).

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 */
}

Flex items

flex-grow controla quanto um item se expande para preencher espaço extra (1 = parcela igual). flex-shrink controla o encolhimento. flex-basis é o tamanho inicial. O shorthand flex: 1 significa crescer igualmente a partir de base zero — perfeito para colunas iguais. align-self sobrescreve o align-items do container para um único item. order reordena visualmente sem mudar a ordem do 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) */
}

Padrões de alinhamento flex

Flexbox torna a centralização trivial: justify-content: center + align-items: center. Um rodapé fixo usa um body flex em coluna com min-height: 100vh e o conteúdo principal com flex: 1. Para barras de navegação, space-between empurra o primeiro e o último item para bordas opostas. Margens automáticas (margin-left: auto) são uma alternativa flexível ao justify-content para empurrar itens.

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 e grid responsivo

flex-wrap: wrap deixa os itens fluírem para novas linhas quando falta espaço. flex: 1 1 280px cria cards que começam com 280px e crescem para preencher a linha. Isso faz um grid de cards responsivo sem media queries. Atenção: os itens da última linha se esticam para preencher, o que pode parecer desigual — para grids de cards consistentes, o CSS Grid costuma ser uma escolha melhor.

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 e eixos

flex-direction determina o eixo principal. Em row (padrão), justify-content controla o alinhamento horizontal; em column, controla o vertical — os eixos trocam. Sempre pergunte 'qual é o eixo principal?' ao alinhar. row-reverse e column-reverse invertem a ordem dos itens, o que também afeta como justify-content distribui o espaço.

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

Container grid

display: grid cria um layout bidimensional. grid-template-columns define as colunas; a unidade fr distribui o espaço livre proporcionalmente. repeat(auto-fit, minmax(200px, 1fr)) é a receita mágica de grids responsivos — as colunas se criam e redimensionam sozinhas, sem media queries. gap adiciona espaço entre as trilhas de forma limpa.

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 desenhar o layout visualmente com regiões nomeadas — extremamente legível. Cada string entre aspas é uma linha; os nomes posicionam itens, e um ponto marca uma célula vazia. Um item com grid-area: name preenche aquela região. É a forma mais clara de construir layouts de página, como 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 .";

Posicionamento de itens no grid

Itens do grid podem ser posicionados explicitamente por números de linha. grid-column: 1 / 3 abrange da linha 1 à linha 3 (cobrindo 2 colunas). A palavra-chave span dimensiona por contagem de trilhas. As linhas também podem ser nomeadas em grid-template-columns para legibilidade. Sem posicionamento explícito, os itens fluem automaticamente para as células disponíveis.

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;
}

Alinhamento no grid

O alinhamento do grid funciona em dois níveis. justify-content/align-content posicionam o grid inteiro dentro do container quando sobra espaço. justify-items/align-items alinham os itens dentro das suas células (stretch por padrão). justify-self/align-self sobrescrevem o alinhamento por item. 'justify' = eixo inline/principal, 'align' = eixo block/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 criam quantas trilhas couberem, mas se comportam diferente com poucos itens. auto-fit colapsa as trilhas não usadas e estica os itens existentes para preencher a linha. auto-fill mantém as trilhas vazias, então os itens ficam no tamanho mínimo. Use auto-fit quando quiser que os itens cresçam e preencham o espaço; use auto-fill quando quiser um tamanho de item fixo e 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

Posicionamento

Valores de position

static é o padrão. relative desloca um elemento da sua posição normal no fluxo (o espaço é preservado). absolute o remove do fluxo e posiciona relativo ao ancestral posicionado mais próximo (ou à viewport). fixed é relativo à viewport do navegador. sticky alterna entre relative e fixed conforme a posição de rolagem — ideal para cabeçalhos fixos.

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; }

Centralização absoluta

Há várias formas de centralizar absolutamente. O truque translate(-50%, -50%) funciona em elementos de qualquer tamanho. A técnica inset: 0 + margin: auto exige dimensões explícitas. A abordagem moderna é display: grid com place-items: center (shorthand de align-items + justify-items) — sem cálculos de posicionamento e a função mais simples.

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; }

Posicionamento sticky

position: sticky mantém um elemento no fluxo normal até atingir um limiar (por exemplo, top: 0), então gruda como fixed. Perfeito para cabeçalhos fixos ou sidebars de sumário. Pegadinha: qualquer ancestral com overflow: hidden/auto/scroll (na direção da rolagem) vira o containing block e quebra o comportamento esperado. Sempre defina um fundo e z-index nos 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 e stacking contexts

z-index só funciona em elementos posicionados (não static). Um stacking context é criado por position + z-index, mas também por opacity < 1, transform, filter, will-change e isolation: isolate. Dentro de um stacking context, os z-index dos filhos ficam isolados — um filho nunca pode renderizar acima de um irmão de um ancestral. Entender isso evita 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; }

Shorthand inset

inset é o shorthand lógico de top, right, bottom e left — como margin/padding, aceita 1, 2 ou 4 valores. inset: 0 estica um elemento absolutamente posicionado para preencher seu containing block. É mais limpo que declarar quatro propriedades separadas e combina bem com margin: auto para centralizar.

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

Estilização de texto

Propriedades de fonte

font-family deve sempre terminar com uma família genérica (serif, sans-serif, monospace) como último recurso. font-weight varia de 100-900; comuns: 400 normal, 700 bold. line-height é melhor sem unidade (1.5) para escalar com o font-size. O shorthand font exige size e family; a ordem é style weight size/line-height family.

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; }

Formatação de texto

text-align: justify pode criar rios de espaço em branco; pareie com hyphens: auto para blocos mais limpos. text-decoration agora aceita line, style e color num único shorthand. text-transform: capitalize capitaliza cada palavra. white-space: nowrap impede a quebra de linha. text-shadow recebe offset-x offset-y blur cor.

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);
}

Overflow de texto e reticências

Truncamento de linha única precisa de três propriedades: white-space: nowrap, overflow: hidden, text-overflow: ellipsis. Para truncamento multilinha, use -webkit-line-clamp com display: -webkit-box (ainda precisa do prefixo -webkit- mas funciona nos navegadores modernos). Um max-width ou width é necessário para o truncamento disparar.

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 e efeitos

text-shadow recebe offset-x offset-y blur-radius cor. Múltiplas sombras se empilham, com a primeira por cima — útil para brilhos neon ou contornos de texto (uma sombra em 4 direções imita um contorno). Diferente de -webkit-text-stroke, text-shadow é suportado universalmente. Sombras duras (sem blur) criam uma estética retrô, tipo adesivo.

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; }

Writing modes e direção

writing-mode controla a direção do texto: horizontal-tb (padrão), vertical-rl (por exemplo, chinês/japonês tradicionais) ou vertical-lr. direction: rtl trata línguas da direita para a esquerda como o árabe. Propriedades lógicas (margin-inline-start, padding-block, inset-inline-end) se adaptam automaticamente ao writing mode e à direção — essenciais para layouts verdadeiramente internacionais e agnósticos de direção.

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

Fundos e gradientes

Shorthand background

O shorthand background aceita todas as propriedades de fundo. Ao usar position e size juntos, separe-os com uma barra (center/cover). Múltiplos fundos se empilham separados por vírgula, o primeiro declarado = o de cima. Uma cor sólida deve sempre vir por último como fallback. Use cover para preencher a caixa e contain para caber a imagem inteira.

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;
}

Gradientes lineares

linear-gradient(direction, color-stops) cria uma transição suave. A direção pode ser uma palavra-chave (to right) ou um ângulo (45deg). Os stops podem incluir posições em porcentagens — colocar dois stops na mesma posição cria uma borda dura (ótimo para listras). Gradientes são imagens, então vão em background-image, e podem ser usados onde quer que imagens sejam aceitas.

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); }

Gradientes radiais e cônicos

radial-gradient irradia de um ponto central — útil para holofotes e botões. Você pode posicionar o centro (at top left) e controlar forma/tamanho (circle, closest-side). conic-gradient gira as cores em torno de um ponto — perfeito para gráficos de pizza e rodas de cores. Stops duros em gradientes cônicos criam fatias de pizza limpas.

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 e origin

background-clip controla até onde o fundo se estende: border-box (padrão, sob a borda), padding-box (dentro da borda) ou content-box (dentro do padding). O truque de manchete: background-clip: text com color: transparent preenche o texto com um gradiente ou imagem. Sempre inclua a versão com prefixo -webkit- para o Safari. background-origin define a área de posicionamento.

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 de fundo e parallax

background-attachment: fixed cria um efeito parallax — o fundo fica fixo enquanto o conteúdo rola sobre ele. scroll (padrão) se move com o elemento; local rola com o conteúdo do elemento (útil para caixas roláveis). Fixed attachment é irregular e mal suportado no mobile; para parallax em produção, use transform: translate3d baseado na posição de rolagem.

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

Bordas e cantos arredondados

border-radius

border-radius arredonda cantos, aceitando 1-4 valores (sentido horário a partir do canto superior esquerdo). Uma barra separa os raios horizontal/vertical para cantos elípticos. border-radius: 50% num quadrado cria um círculo perfeito; num retângulo, uma elipse. Propriedades longhand (border-top-left-radius) controlam cantos individuais. Cantos arredondados cortam fundos, bordas e (com overflow: hidden) o conteúdo filho.

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 fatia uma imagem em 9 regiões e aplica os cantos/arestas a uma borda. border-image-slice divide a imagem de origem; repeat controla como as arestas se repetem. Um truque moderno comum: usar border-image com um linear-gradient e slice 1 para criar bordas com gradiente. Nota: border-image substitui border-style, então defina border-width antes.

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;
}

Múltiplas bordas

CSS não consegue empilhar várias propriedades border, mas há alternativas. box-shadow com offset zero e spread cria bordas externas nítidas (funciona com border-radius). outline desenha uma segunda borda por fora, mas ignora border-radius. Um pseudo-elemento dá controle total, inclusive do raio. Cada técnica tem tradeoffs — escolha conforme precisar de cantos arredondados.

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;
}

Bordas com gradiente

Bordas com gradiente são complicadas porque border-image não suporta border-radius. A solução robusta: empilhar dois fundos — uma cor sólida cortada em padding-box e um gradiente cortado em border-box, com uma borda transparente. Isso respeita o border-radius e funciona nos lugares. A função mais simples com border-image funciona quando você não precisa de cantos arredondados.

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 e estilos de foco

outline desenha fora da borda e não afeta o layout, tornando-o ideal para indicadores de foco. outline-offset adiciona um espaço. Regra crítica de acessibilidade: nunca defina outline: none sem uma alternativa visível. :focus-visible mostra o contorno apenas para navegação por teclado (não cliques de mouse) — a abordagem moderna e amigável para estilização 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

Transforms

Transforms 2D

Transforms 2D — translate, rotate, scale, skew — movem e distorcem elementos sem afetar o layout (irmãos não refluem). Transforms combinados aplicam da direita para a esquerda, então a ordem importa: rotate antes de translate move ao longo do eixo rotacionado. Como transforms não disparam reflow, são ideais para animações e são acelerados 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 define o ponto de pivô dos transforms — o padrão é o centro do elemento. Aceita palavras-chave (top left), pixels ou porcentagens. Mudar a origem altera drasticamente o comportamento de rotação e escala: um card que vira pela borda superior precisa de transform-origin: top. Para transforms 3D, um terceiro valor do eixo z pode ser especificado.

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 */

Transforms 3D

Transforms 3D adicionam rotateX, rotateY, rotateZ, translateZ e scaleZ. perspective(n) deve ser aplicada como primeira função de transform (ou no pai) para habilitar profundidade — valores menores exageram o efeito 3D. translate3d e scale3d são acelerados por GPU e têm melhor desempenho em animações que suas contrapartes 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); }

Perspective e espaço 3D

perspective define a distância do observador — menor = 3D mais dramático. Coloque no pai para que os filhos compartilhem o mesmo ponto de fuga. transform-style: preserve-3d permite que elementos aninhados vivam num espaço 3D compartilhado (essencial para construir cubos). backface-visibility: hidden oculta o verso de um elemento — chave para efeitos de card que gira.

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; }

Animando transforms (desempenho)

Sempre anime transform e opacity — são acelerados por GPU e não disparam layout (reflow) nem paint. Animar top/left/width/margin força o navegador a recalcular o layout a cada frame, causando jank. will-change: transform dá uma dica ao navegador para preparar uma camada de compositor com antecedência, mas o uso excessivo desperdiça memória. Aplique logo antes de uma animação e remova depois.

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

Transições

Shorthand transition

transition: propriedade duração timing-function delay. O padrão é all 0s ease 0s — então só escrever transition: 0.3s anima todas as propriedades alteradas. Por desempenho e controle, liste propriedades específicas. Múltiplas transições são separadas por vírgula. A transition vai no estado padrão do elemento (não no :hover), para que a animação reversa também aconteça.

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);
}

Funções de timing

Funções de timing controlam a aceleração. ease (padrão) é suave. ease-out parece a mais responsiva para UI (início rápido, fim lento). linear parece antinatural para a maioria dos movimentos. cubic-bezier(x1,y1,x2,y2) permite criar curvas personalizadas — valores fora de 0-1 no eixo y criam overshoot/bounce. steps(n) cria saltos discretos, úteis para animações 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); }

Transições múltiplas e escalonadas

Propriedades diferentes podem ter durações e delays diferentes — útil para efeitos coreografados em que uma propriedade termina antes de outra começar. transition-delay cria entradas escalonadas para listas; combine com nth-child para atrasar cada item progressivamente. Delays também funcionam para saídas, mas cuidado: se o usuário tirar o hover no meio do delay, a entrada pode se assentar de repente.

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; }

Propriedades transicionáveis

Algumas propriedades transicionam suavemente; outras causam jank. As estrelas aceleradas por GPU são transform, opacity e filter. Cores e box-shadow são aceitáveis (disparam paint, não layout). Evite transicionar width, height, margin, top, left — forçam recálculo de layout a cada frame. Para animar uma mudança de tamanho, use transform: scale().

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; }

Gatilhos de transição

Transições disparam em qualquer mudança de propriedade: estados de pseudo-classe (:hover, :focus, :checked), mudanças de classe (adicionadas/removidas por JS) e mudanças de media query. Elas interpolam entre os valores antigo e novo suavemente. Transições só rodam a caminho do novo estado — ambas as direções (entrada/saída) animam. Para movimento mais complexo, em loop ou em múltiplos passos, use animações @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

Animações

@keyframes

@keyframes define a sequência de uma animação. Os stops podem ser porcentagens (0%, 50%, 100%) ou from/to (equivalentes a 0%/100%). Propriedades não listadas num stop interpolam entre os stops definidos. Só propriedades animáveis (transform, opacity, cores) funcionam — display, position etc. não. Defina @keyframes uma vez e reutilize em muitos 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); }
}

Shorthand animation

O shorthand animation comprime 8 propriedades nesta ordem: name duration timing-function delay iteration-count direction fill-mode play-state. No mínimo você precisa de name e duration. Nota: ambiguidade de valor de tempo sem unidade — o primeiro tempo é duration, o segundo é delay. Para legibilidade em produção, prefira longhand ou shorthand 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;
}

Iteração e direção

animation-iteration-count controla a repetição — infinite faz loop para sempre, valores fracionários reproduzem ciclos parciais. animation-direction: alternate reproduz a animação para frente e depois para trás na próxima iteração, criando um bounce contínuo. reverse reproduz para trás, e alternate-reverse começa para trás. Alternate é essencial para movimentos de ping-pong como pulsos ou efeitos de respiração.

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; }

Animation fill mode

animation-fill-mode controla os estilos antes e depois da animação rodar. none (padrão) volta aos estilos normais do elemento. forwards mantém o estado do keyframe final após terminar — essencial para animações de entrada, para que os elementos não voltem de repente. backwards aplica o primeiro keyframe durante o delay. both cobre os dois casos. Use forwards ou both para entradas de uso único.

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; }

Play state e pausa

animation-play-state: paused congela uma animação no frame atual; running a retoma. Essa é a forma mais limpa de pausar no hover ou via classe alternada por JS — a animação lembra sua posição em vez de reiniciar. Por desempenho, pause animações em elementos que saem da tela usando IntersectionObserver. Combine com media queries de reduced-motion por acessibilidade.

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

Sintaxe básica

Media queries aplicam estilos condicionalmente. (min-width: 768px) é mobile-first — aplica em telas de 768px para cima. Combine com and (ambos devem casar), vírgulas (OU) e not (negação). A abordagem mobile-first (min-width) é a preferida: escreva estilos base para telas pequenas, depois aprimore para as maiores. Isso mantém o CSS de telas pequenas enxuto.

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 min/max width

Breakpoints devem se basear no conteúdo, não em dispositivos específicos, mas faixas comuns funcionam bem: 640px (tablet), 1024px (desktop), 1280px (grande). Mobile-first significa usar min-width e escrever os estilos mobile como base. A sintaxe de faixa mais nova (width >= 768px) é mais legível e suportada nos navegadores modernos, substituindo combinações verbosas de min/max.

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; }
}

Orientação e aspect ratio

Além da largura, media queries podem mirar orientação (portrait/landscape), aspect-ratio, capacidade de hover e tipo de ponteiro. @media (hover: hover) garante que estilos de hover só apliquem em dispositivos com ponteiro real (evitando hover pegajoso no touch). (pointer: coarse) mira dispositivos de toque — perfeito para ampliar alvos de toque. Esses recursos habilitam interfaces realmente adequadas ao 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 impressão

Media queries de impressão estilizam como as páginas aparecem quando impressas. Oculte navegação, anúncios e elementos interativos; expanda o conteúdo para largura total; force preto no branco para economizar tinta. break-inside: avoid impede que elementos se dividam entre páginas, e break-before: page força quebras de página. O truque ::after em links revela as URLs na impressão — valioso para artigos imprimíveis.

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 e color-scheme

prefers-reduced-motion é um recurso crítico de acessibilidade — usuários com distúrbios vestibulares precisam de movimento minimizado. Sempre forneça um fallback de movimento reduzido que desabilite ou encurte animações. prefers-color-scheme permite se adaptar automaticamente ao tema do SO do usuário. Para modo escuro, considere também contraste, imagens e sombras que funcionem em fundos escuros.

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

Design responsivo

Tipografia fluida com clamp()

clamp(min, preferido, max) cria valores que escalam fluidamente entre limites — perfeito para tipografia e espaçamento que se adaptam sem media queries. O valor preferido costuma ser uma expressão baseada em vw. Isso elimina muitos breakpoints. Pareie com rem por acessibilidade (usuários ainda podem escalar o font-size raiz). Tipografia fluida melhora a percepção de desempenho e a legibilidade entre dispositivos.

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;
}

Abordagem mobile-first

Mobile-first significa escrever os estilos de telas pequenas como base, depois usar media queries min-width para aprimorar para telas maiores. Isso produz CSS mais enxuto (o mobile baixa só o que precisa) e força uma mentalidade de priorização de conteúdo. Desktop-first (max-width) força dispositivos móveis a baixar e sobrescrever estilos de desktop — mais lento e mais difícil de manter.

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

Container queries mudam o jogo: permitem que componentes respondam ao tamanho do pai, não da viewport. Um card pode adaptar seu layout tanto numa sidebar estreita quanto numa área principal larga — responsividade verdadeira no nível do componente. container-type: inline-size consulta a largura (o mais performático). Nomeie containers para mirá-los especificamente, ou use queries sem nome para o ancestral mais próximo.

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 são porcentagens da viewport. O problema: 100vh no mobile muda conforme a barra de endereço aparece/some, causando jank. As unidades mais novas svh/lvh/dvh resolvem isso — dvh atualiza dinamicamente, svh usa o menor valor estável. vmin/vmax são a menor/maior dimensão da viewport — ótimo para elementos quadrados que escalam. Sempre pareie tamanhos de fonte em vw com um piso em rem/px via calc ou 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 mantém uma proporção largura:altura automaticamente — acabaram os hacks de padding-top para vídeo responsivo. A altura do elemento deriva da largura (ou vice-versa). Combinado com object-fit: cover em imagens, evita deslocamento de layout conforme as imagens carregam. É a forma mais limpa de reservar espaço para mídia e evitar cumulative layout shift (CLS) — um 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

Custom properties (variáveis)

Definindo e usando variáveis

Custom properties CSS (variáveis) são declaradas com --name e usadas com var(--name). Defina-as em :root para acesso global, ou escopo-as a qualquer elemento. Diferente de variáveis de pré-processador, elas são vivas: mudar uma variável atualiza os usos em tempo real, e elas fazem cascata e herdam. var() aceita um fallback como segundo argumento, usado quando a variável é indefinida.

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;
}

Temas e modo escuro

Custom properties tornam a tematização trivial: defina variáveis semânticas (--bg, --text, --primary), depois sobrescreva-as num seletor [data-theme]. Alternar o atributo data-theme no <html> troca o tema inteiro instantaneamente — sem folhas de estilo duplicadas. Combine com prefers-color-scheme para modo escuro automático que respeita a escolha manual do usuário. Essa é a forma moderna e performática 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;
  }
}

Cascata e herança

Custom properties fazem cascata e herdam como CSS normal. Uma variável definida em .card está disponível para .card e os descendentes — mas não para irmãos. Cada elemento lê o valor computado da variável no seu próprio escopo. @property (mais novo) permite declarar variáveis tipadas com uma syntax, valor inicial e flag de herança — habilitando transições e animações suaves de custom properties.

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;
}

Interação com JavaScript

Variáveis CSS são totalmente acessíveis do JavaScript. Leia com getComputedStyle(el).getPropertyValue('--name') (retorna uma string, frequentemente com espaço inicial — faça trim). Defina com el.style.setProperty('--name', value). Isso faz das custom properties uma ponte poderosa de JS para CSS: atualize uma variável em JS e o CSS reage instantaneamente — perfeito para efeitos dirigidos por rolagem, temas e 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)); }

Fallbacks e encadeamento

var() suporta um fallback como segundo argumento, usado apenas quando a variável é indefinida (não quando é inválida — valores inválidos fazem a propriedade inteira voltar ao seu default). Fallbacks podem se encadear: var(--a, var(--b, #default)). Isso é útil para progressive enhancement e integração de componentes de terceiros. Use @supports (--x: 0) para detectar suporte, embora os navegadores modernos suportem custom properties.

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

Funções de filtro

filter aplica efeitos visuais a um elemento. brightness/contrast/saturate recebem multiplicadores (1 = normal) ou porcentagens. hue-rotate desloca os matizes por um ângulo. Múltiplos filtros se encadeiam da esquerda para a direita. Uso comum: imagens em tons de cinza no hover, efeitos de foto vintage ou escurecimento de fundos. Filtros afetam o elemento, seu fundo, bordas e filhos.

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 é o equivalente em filtro do box-shadow — mas segue a forma real de alpha do elemento, não sua caixa. Isso significa que sombras abraçam recortes de PNG/SVG e formas irregulares. Use para sombras de ícones, logos brilhantes ou qualquer elemento não retangular. Múltiplos drop-shadows podem ser empilhados. Nota: pode ser mais caro que box-shadow, então use com discernimento.

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 um filtro a tudo atrás de um elemento — a assinatura do glassmorphism. Um fundo semitransparente mais backdrop-filter: blur() cria o visual de vidro fosco. Sempre inclua o prefixo -webkit- para o Safari. O elemento precisa de alguma transparência no fundo para o efeito aparecer. Combine com saturate() para resultados vibrantes, e adicione uma borda sutil para simular reflexo de borda.

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);
}

Combinando filtros

Múltiplos filtros se aplicam da esquerda para a direita, então a ordem afeta o resultado (grayscale antes de hue-rotate não tem nada para rotacionar, por exemplo). Filtros são animáveis e acelerados por GPU — ótimos para efeitos de hover. Pareie filter com mix-blend-mode para misturar um elemento com seu fundo. Para controle dinâmico, guarde a cadeia de filtros numa custom property e atualize via 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;
}

Desempenho de filtros

Filtros são acelerados por GPU, mas não são grátis. Blurs grandes em elementos de tela cheia causam repaints pesados e jank, especialmente no mobile. Mantenha os raios de blur pequenos, limite a área filtrada e aplique will-change: filter antes de disparar animações. backdrop-filter é particularmente caro — use em pequenos elementos de UI, não em seções inteiras. contain: paint isola a área de repaint para melhor desempenho.

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 e ::after

::before e ::after inserem conteúdo gerado antes/depois do conteúdo real de um elemento. A propriedade content é obrigatória (mesmo que string vazia para elementos decorativos). O conteúdo pode ser texto, Unicode escapado ou valores de atributos via attr(). Esses pseudo-elementos são inline por padrão — defina display: block para decoração em forma de caixa. Perfeitos para ícones, linhas decorativas, aspas e limpar 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 e ::first-line

::first-letter estiliza o primeiro caractere — perfeito para capitulares em artigos. ::first-line estiliza a primeira linha formatada, que se ajusta dinamicamente conforme a viewport muda de largura. Ambos só funcionam em elementos block-level. Note que ::first-letter só se aplica quando o primeiro caractere não é precedido por outro conteúdo (como imagens). São essenciais de tipografia para layouts editoriais.

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 a parte do texto que o usuário seleciona. Só um punhado de propriedades se aplica: color, background-color, text-shadow e text-decoration. Use para dar a cor de seleção a identidade do seu site. Aplique globalmente com ::selection ou escopo a elementos específicos. Firefox antigo precisava de ::-moz-selection, mas o Firefox moderno suporta o padrão ::selection.

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 e ::marker

::placeholder estiliza o texto de placeholder em inputs de formulário — defina opacity: 1 porque o Firefox usa um placeholder translúcido por padrão. ::marker estiliza bullets ou números de list-item, e suporta um conjunto limitado de propriedades (color, content, font, direction). Você pode substituir bullets por conteúdo personalizado (Unicode, counters). Esses pseudo-elementos colocam a estilização de formulários e listas totalmente sob controle do designer.

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 */

Conteúdo gerado e counters

Conteúdo gerado via ::before/::after pode incluir valores counter(), valores de atributos (attr()) ou literais de string — habilitando numeração, ícones e tooltips só com CSS, sem DOM extra. counters() produz numeração aninhada como '1.2.3'. Tooltips construídos com attr(data-tooltip) e uma transição de hover são uma alternativa leve a bibliotecas JS. Lembre: conteúdo gerado não está no DOM e não é lido por alguns leitores de tela — não coloque conteúdo crítico lá.

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

Counters

counter-reset e counter-increment

Counters CSS permitem numerar elementos sem JavaScript. counter-reset inicializa um counter (padrão 0, mas você pode começar em outro valor). counter-increment o aumenta (padrão 1, mas qualquer inteiro funciona — até negativo). Exiba o valor com counter() dentro de content. Counters têm escopo no elemento onde foram resetados e seus descendentes, habilitando numeração aninhada.

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 */

Função counter()

counter(name) exibe o valor atual de um counter, e counter(name, style) aplica um estilo de lista: decimal (padrão), lower/upper-alpha, lower/upper-roman, disc, square e mais. Você pode rodar múltiplos counters em paralelo e combiná-los em content — perfeito para figuras numeradas por capítulo (Figura 3-2). Os valores dos counters são calculados em tempo de renderização, então se atualizam automaticamente quando o DOM muda.

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) ": ";
}

Counters aninhados com counters()

counters(name, separador) é a função de counters aninhados: concatena o valor do counter em cada escopo ancestral, separado pela string dada. Isso produz numerações como '1.2.3' automaticamente — o mesmo nome de counter é resetado em cada <ol> aninhado. Sem counters() (plural), listas aninhadas compartilhariam a mesma numeração. O separador pode ser qualquer string, como '.' ou '-'.

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, "-") ": "; }

Estilização de counters

Counters suportam muitos estilos embutidos: decimal, upper-roman, lower-alpha, lower-greek, cjk-decimal e mais. @counter-style permite definir estilos personalizados com um conjunto de símbolos, um system (cyclic, additive, extends) e opções como pad (zeros à esquerda), prefix/suffix e range. Ótimo para listas temáticas, bullets de emoji ou numeração localizada sem 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, ... */
}

Padrões práticos de counters

Counters brilham em indicadores de passos numerados, sumários e numerações. Estilize o ::before com um badge circular, cor e número para criar listas de passos numeradas sem numeração manual. Edite o DOM e os números se atualizam sozinhos. Ressalva: valores de counter não podem ser lidos facilmente pelo JavaScript — são só para exibição. Para lógica baseada em contagens, use JS ou 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 multicoluna

column-count e column-width

Layout multicoluna flui o conteúdo em colunas estilo jornal. column-count fixa o número; column-width deixa o navegador criar quantas colunas de 250px couberem (responsivo sem media queries). O shorthand columns recebe count e/ou width. Multicoluna é ideal para texto de leitura longa, mas cuidado: conteúdo curto pode causar alturas de coluna desiguais.

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 e column-rule

column-gap define o espaço entre colunas (também usado por flexbox e grid hoje). column-rule desenha uma linha divisória vertical no espaço — é o equivalente de border para colunas, com o mesmo shorthand. A regra não ocupa largura extra; fica centrada no espaço. Use uma cor sutil para delimitar colunas sem ser 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 faz um elemento romper por todas as colunas — perfeito para uma manchete estilo revista que atravessa a largura total com colunas fluindo acima e abaixo. column-span: none (padrão) mantém o conteúdo fluindo pelas colunas. Saiba que isso pode causar reflow significativo e já teve suporte inconsistente; teste bem. É mais confiável para títulos entre blocos de colunas.

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 e quebras de coluna

Conteúdo multicoluna pode dividir elementos de forma estranha entre colunas. break-inside: avoid mantém um elemento (como um card ou figura) intacto numa única coluna. break-before/break-after: column forçam quebras de coluna. As propriedades antigas page-break-* funcionam como aliases. Um hack comum era display: inline-block com width: 100%, mas break-inside: avoid é a abordagem moderna e correta.

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 e balanceamento

column-fill controla como o conteúdo se distribui pelas colunas. balance (padrão) iguala as alturas para que as colunas terminem aproximadamente alinhadas — visualmente arrumado. auto preenche a primeira coluna por completo antes de passar à seguinte, exigindo altura fixa; isso corresponde ao comportamento de impressão. Colunas balanceadas são melhores para uso geral; auto é melhor quando o conteúdo deve fluir estritamente de cima a baixo.

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

Interface do usuário

Outline e acessibilidade

Indicadores de foco visíveis são um requisito de acessibilidade. :focus-visible mostra o contorno apenas para usuários de teclado (não de mouse), a melhor prática para estilização de foco. Nunca defina outline: none sem substituição (como um anel de box-shadow). outline-offset adiciona espaço entre o elemento e o contorno. Navegadores modernos suportam contornos arredondados via border-radius afetando a forma do contorno.

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 se o usuário pode redimensionar um elemento arrastando. textarea é redimensionável por padrão; resize: none desabilita. vertical/horizontal/both restringem a direção. Para o resize funcionar, o elemento precisa de overflow diferente de visible (defina overflow: auto ou hidden). Útil para textareas, editores de código ou qualquer painel ajustável pelo usuário.

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 e user-select

caret-color define a cor do cursor piscante em elementos editáveis — um toque pequeno, mas bacana, para formulários com identidade. user-select controla se o texto pode ser selecionado: none desabilita (para controles de UI), all seleciona o elemento inteiro ao clicar (bom para blocos de código ou e-mails) e contain mantém a seleção dentro de um elemento. Evite user-select: none no body — prejudica a acessibilidade.

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 e estilização de formulários

appearance: none remove a estilização nativa do SO dos controles de formulário, permitindo estilizá-los totalmente com CSS — essencial para design de formulários consistente entre navegadores. Depois de remover a seta nativa do select, adicione um background-image personalizado. Checkboxes personalizados usam appearance: none mais :checked para o estado. Sempre prefixe com -webkit-/-moz- para suporte completo. Teste bem entre navegadores — alguns controles (date, color) continuam difíceis de reestilizar totalmente.

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 e scrollbar

scroll-behavior: smooth no <html> faz os cliques em links de âncora animarem até o alvo em vez de saltar — pareie com prefers-reduced-motion para desabilitar para usuários sensíveis. Scrollbars personalizadas: as propriedades padrão scrollbar-width/scrollbar-color funcionam no Firefox e no Chrome moderno; os pseudo-elementos ::-webkit-scrollbar dão controle mais fino em WebKit/Blink. Scrollbars personalizadas sutis refinam a UX de áreas roláveis.

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

Recursos avançados e modernos

Scroll Snap

Scroll Snap cria rolagem tipo carrossel ou de página inteira sem JavaScript. scroll-snap-type: x/y + mandatory/proximity controla o eixo e a rigidez. Filhos com scroll-snap-align se ancoram em start/center/end. mandatory força a ancoragem (bom para seções de página inteira); proximity só ancora quando perto (mais suave, para galerias de imagens). Combine com scroll-margin para deslocar pontos de ancoragem sob cabeçalhos sticky.

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 e object-position

object-fit controla como um <img> ou <video> preenche sua caixa — o equivalente de mídia do background-size. cover preenche a caixa e corta o excesso; contain cabe toda a mídia com possível espaço vazio; fill estica (distorce). object-position define o ponto focal — útil quando cover corta partes importantes de uma imagem. Elimina a necessidade de hacks de background-image para mídia responsiva.

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 dá uma dica ao navegador de que uma propriedade mudará em breve, deixando-o pré-alocar camadas de GPU e otimizar. Aplique logo antes de uma animação e remova depois — uso permanente em muitos elementos desperdiça memória e pode prejudicar o desempenho. Liste apenas propriedades que realmente animarão (transform, opacity, filter). O uso excessivo dispara o efeito oposto ao pretendido, então use com parcimônia e intenção.

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 informa ao navegador que um elemento é independente do resto da página, habilitando grandes otimizações de desempenho — mudanças dentro de um elemento contido não disparam recálculo fora dele. layout, paint, style e size são os tipos de isolamento. strict (os quatro, incluindo size) é o mais forte. Aplique contain a widgets repetidos, itens de lista ou anúncios para limitar o custo de reflow/repaint. size exige dimensões 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 e gap universal

aspect-ratio mantém uma proporção largura:altura em qualquer elemento, evitando deslocamento de layout conforme a mídia carrega. gap (e seus longhand row-gap/column-gap) é a ferramenta moderna de espaçamento, funcionando em flexbox, grid e multicoluna — eliminando os hacks .item + margin + :last-child. Ambos são suportados universalmente em navegadores modernos e, juntos, resolvem duas das maiores dores de cabeça do CSS: manter proporções de mídia e espaçar itens de forma limpa.

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.