Skip to content

CSS3 Spickzettel

Neueste Evolution von CSS mit Modulen für Styling, Layout und Animation.

01

Selektoren

Attribut- & Pseudoklassen-Selektoren

CSS3 brachte mächtige Attribut-Selektoren und Pseudoklassen. ^= matcht Präfix, $= matcht Suffix, *= matcht Teilstring. nth-child ermöglicht Zebra-Streifen ohne 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; }

Strukturale Pseudoklassen

Strukturale Pseudoklassen wählen Elemente nach ihrer Position im DOM. :first-child / :last-child zielen auf die Ränder. nth-child(an+b) unterstützt Formeln: 2n ist gerade, 2n+1 ungerade, 3n jede dritte. :nth-of-type zählt nur Geschwister desselben Elementtyps. :empty matcht Elemente ohne Kinder.

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

:is() und :where() gruppieren Selektoren zur Kürze. Der Unterschied: :is() übernimmt die höchste Spezifität seiner Argumente, :where() hat immer Spezifität null — ideal für leicht übersteuerbare Basis-Stile. :has() ist der lang ersehnte Parent-/Relational-Selektor, der Elemente anhand ihrer Nachfahren stylt.

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

Negation & Formular-Pseudoklassen

:not() negiert einen Selektor und akzeptiert inzwischen eine Liste. Formular-Pseudoklassen (:required, :valid, :invalid, :checked, :placeholder-shown, :in-range) ermöglichen Styling nach Input-Zustand ganz ohne JavaScript — perfekt für Inline-Validierungs-Feedback und eigenes checkbox/radio-Styling.

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

Spezifität & Kaskade

Die Spezifität entscheidet, welche Regel gilt, wenn Selektoren kollidieren. IDs, Klassen und Elemente als (a,b,c) zählen. !important übersteuert die Kaskade, aber untergräbt die Wartbarkeit — vermeiden. Bei Spezifitäts-Gleichstand gewinnt die spätere Regel in der Quelldatei. DevTools zeigt die berechnete Kaskade.

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-Modell

box-sizing

box-sizing: border-box rechnet padding und border in die deklarierte width/height hinein und macht Größen vorhersagbar. content-box (Default) rechnet sie obendrauf. border-box global anzuwenden ist das wichtigste CSS-Reset — es beseitigt die häufigsten Layout-Rechen-Kopfschmerzen.

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 & Padding

Padding liegt innerhalb des Rahmens (erbt den Hintergrund); margin liegt außerhalb (transparent). Vertikale margins benachbarter Blockelemente kollabieren zum größeren Wert — horizontale margins kollabieren nie. margin: 0 auto zentriert ein Blockelement mit definierter Breite. Negative margins können Inhalt ziehen — sparsam einsetzen.

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

box-shadow-Syntax: offset-x offset-y blur-radius spread-radius color. Positive Offsets schieben den Schatten nach rechts/unten. inset erzeugt einen inneren Schatten. Mehrere Schatten schichten sich, der erste liegt oben. rgba für durchscheinende, natürliche Schatten. Harte Schatten (null blur) erzeugen eine flache, kraftvolle Ästhetik.

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

Display-Typen

display: none entfernt das Element aus dem Layout (kein Platz reserviert). block-Elemente nehmen die volle Breite und stapeln vertikal; inline-Elemente fließen mit dem Text und ignorieren width/height. inline-block kombiniert Inline-Fluss mit Block-Größen. flow-root clear't floats ohne clearfix-Hacks. contents lässt die Box verschwinden, hält aber die Kinder im 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 steuert, wie über die Box hinausgehender Inhalt behandelt wird. visible (Default) lässt ihn überlaufen; hidden schneidet; auto ergänzt Scrollbars bei Bedarf; scroll zeigt sie immer. clip (neuer) ist wie hidden, verhindert aber jedes Scrollen, auch via JS. overflow-y/x steuern die Achsen unabhängig. overflow anders als visible schafft einen neuen formatting context.

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

Flex-Container

display: flex macht ein Element zum flex container. justify-content richtet Items entlang der Hauptachse aus (horizontal in row); align-items entlang der Querachse. flex-wrap lässt Items in neue Zeilen umbrechen. gap ersetzt den margin-basierten Abstands-Hack. Flexbox glänzt bei eindimensionalen Layouts (Reihen oder Spalten).

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 steuert, wie weit ein Item sich auf zusätzlichen Raum ausdehnt (1 = gleicher Anteil). flex-shrink steuert das Schrumpfen. flex-basis ist die Ausgangsgröße. Die Kurzfassung flex: 1 heißt gleichmäßig wachsen ab Null-Basis — perfekt für gleiche Spalten. align-self übersteuert das align-items des Containers für ein einzelnes Item. order ordnet visuell um, ohne die DOM-Reihenfolge zu ändern.

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

Flex-Ausrichtungsmuster

Flexbox macht Zentrieren trivial: justify-content: center + align-items: center. Ein sticky footer nutzt einen column-flex-body mit min-height: 100vh und dem Hauptinhalt auf flex: 1. Bei Navigationsleisten schiebt space-between das erste und letzte Item an gegenüberliegende Kanten. Auto-margins (margin-left: auto) sind eine flexible Alternative zu justify-content zum Schieben von Items.

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 & responsives Gitter

flex-wrap: wrap lässt Items in neue Zeilen fließen, wenn der Platz ausgeht. flex: 1 1 280px erzeugt Karten, die bei 280px starten und die Reihe füllend wachsen. So entsteht ein responsives Kartengitter ohne media queries. Achtung: die Items der letzten Reihe dehnen sich zum Füllen — wirkt ggf. ungleichmäßig; für konsistente Kartengitter ist CSS Grid oft die bessere Wahl.

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 & Achsen

flex-direction bestimmt die Hauptachse. In row (Default) steuert justify-content die horizontale Ausrichtung; in column die vertikale — die Achsen tauschen. Beim Ausrichten immer fragen: 'Welche ist die Hauptachse?'. row-reverse und column-reverse kippen die Item-Reihenfolge, was auch die Raumverteilung von justify-content beeinflusst.

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

Grid-Container

display: grid erzeugt ein zweidimensionales Layout. grid-template-columns definiert Spalten-Tracks; die fr-Einheit verteilt freien Platz anteilig. repeat(auto-fit, minmax(200px, 1fr)) ist das Zauberrezept für responsive grids — Spalten entstehen und skalieren automatisch ohne media queries. gap ergänzt sauber Platz zwischen Tracks.

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 erlaubt, das Layout visuell mit benannten Regionen zu zeichnen — äußerst lesbar. Jeder quoted String ist eine Zeile; Namen platzieren Items, ein Punkt markiert eine leere Zelle. Ein Item mit grid-area: name füllt diese Region. Der klarste Weg zu seitenweiten Layouts wie 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 .";

Grid-Item-Platzierung

Grid-Items lassen sich explizit per Liniennummern platzieren. grid-column: 1 / 3 spannt von Linie 1 bis Linie 3 (deckt 2 Spalten). Das span-Keyword misst nach Trackzahl. Linien lassen sich in grid-template-columns auch benennen — lesbarer. Ohne explizite Platzierung fließen Items automatisch in freie Zellen.

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

Grid-Ausrichtung

Grid-Ausrichtung wirkt auf zwei Ebenen. justify-content/align-content positionieren das gesamte grid im Container bei Restplatz. justify-items/align-items richten Items in ihren Zellen aus (Default stretch). justify-self/align-self übersteuern die Ausrichtung pro Item. 'justify' = inline/Hauptachse, 'align' = block/Querachse.

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

Beide erzeugen so viele Tracks wie passen, verhalten sich aber bei wenigen Items verschieden. auto-fit kollabiert ungenutzte Tracks und dehnt bestehende Items zur Reihenfüllung. auto-fill behält leere Tracks, Items bleiben auf ihrer min-Größe. auto-fit, wenn Items wachsen und Raum füllen sollen; auto-fill bei fester, konsistenter Item-Größe.

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

Positionierung

Position-Werte

static ist der Default. relative versetzt ein Element von seiner normalen Flussposition (Platz bleibt reserviert). absolute nimmt es aus dem Fluss und positioniert es relativ zum nächsten positionierten Vorfahren (oder Viewport). fixed ist relativ zum Browser-Viewport. sticky wechselt je Scrollposition zwischen relative und fixed — ideal für sticky headers.

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

Absolutes Zentrieren

Mehrere Wege zum absoluten Zentrieren. Der translate(-50%, -50%)-Trick funktioniert auf Elementen jeder Größe. inset: 0 + margin: auto verlangt explizite Maße. Der moderne Ansatz ist display: grid mit place-items: center (Kurzfassung von align-items + justify-items) — keine Positions-Mathematik und die simpelste Methode.

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

Sticky-Positionierung

position: sticky hält ein Element im normalen Fluss, bis es eine Schwelle erreicht (z. B. top: 0), und klebt dann wie fixed. Perfekt für sticky headers oder Inhaltsverzeichnis-Seitenleisten. Stolperfalle: jeder Vorfahre mit overflow: hidden/auto/scroll (in Scrollrichtung) wird zum containing block und bricht das erwartete Verhalten. Sticky-Elementen immer Hintergrund und z-index geben.

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 & Stacking-Contexts

z-index wirkt nur auf positionierte (non-static) Elemente. Ein stacking context entsteht durch position + z-index, aber auch durch opacity < 1, transform, filter, will-change und isolation: isolate. Innerhalb eines stacking contexts sind Kind-z-index-Werte isoliert — ein Kind kann nie über einem Geschwister eines Vorfahren rendern. Das zu verstehen verhindert z-index-Eskalationskriege.

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

inset-Kurzfassung

inset ist die logische Kurzfassung von top, right, bottom und left — wie margin/padding nimmt sie 1, 2 oder 4 Werte. inset: 0 dehnt ein absolut positioniertes Element auf seinen containing block aus. Sauberer als vier separate Eigenschaften und paart sich gut mit margin: auto zum Zentrieren.

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

Text-Styling

Font-Eigenschaften

font-family sollte immer mit einer generischen Familie enden (serif, sans-serif, monospace) als letzter Ausweg. font-weight reicht 100-900; üblich: 400 normal, 700 bold. line-height am besten ohne Einheit (1.5), damit sie mit font-size skaliert. Die font-Kurzfassung verlangt size und family; Reihenfolge: 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; }

Text-Formatierung

text-align: justify kann Weißraum-Flüsse erzeugen; mit hyphens: auto paaren für sauberere Blöcke. text-decoration akzeptiert line, style und color in einer Kurzfassung. text-transform: capitalize setzt jedes Wort groß. white-space: nowrap verhindert Umbruch. text-shadow nimmt 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);
}

Text-Overflow & Ellipsis

Einzeilige Kürzung braucht drei Eigenschaften: white-space: nowrap, overflow: hidden, text-overflow: ellipsis. Für mehrzeilige Kürzung -webkit-line-clamp mit display: -webkit-box nutzen (braucht weiterhin das -webkit--Präfix, funktioniert aber in allen modernen Browsern). Eine max-width oder width ist nötig, damit die Kürzung greift.

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 & Effekte

text-shadow nimmt offset-x offset-y blur-radius color. Mehrere Schatten schichten sich, der erste liegt oben — nützlich für Neon-Glows oder Text-Umrisse (ein 4-Richtungen-Schatten imitiert einen Umriss). Anders als -webkit-text-stroke ist text-shadow universell unterstützt. Harte Schatten (kein blur) erzeugen eine retro, sticker-artige Ästhetik.

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-mode & direction

writing-mode steuert die Textrichtung: horizontal-tb (Default), vertical-rl (z. B. traditionelles Chinesisch/Japanisch) oder vertical-lr. direction: rtl behandelt rechts-nach-links-Sprachen wie Arabisch. Logische Eigenschaften (margin-inline-start, padding-block, inset-inline-end) passen sich automatisch an writing mode und direction an — Pflicht für wirklich internationale, richtungsunabhängige Layouts.

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

Hintergründe & Gradients

background-Kurzfassung

Die background-Kurzfassung akzeptiert alle background-Eigenschaften. Bei position und size zusammen mit Slash trennen (center/cover). Mehrere Hintergründe schichten sich kommasepariert, zuerst deklariert = oben. Eine Volltonfarbe gehört als Fallback immer ans Ende. cover füllt die Box, contain passt das ganze Bild ein.

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

Lineare Gradients

linear-gradient(direction, color-stops) erzeugt einen geschmeidigen Übergang. Die Richtung kann ein Keyword (to right) oder ein Winkel (45deg) sein. Stops können Positionsangaben als Prozent tragen — zwei Stops auf derselben Position erzeugen eine harte Kante (super für Streifen). Gradients sind Bilder, gehen also auf background-image, und sind überall nutzbar, wo Bilder akzeptiert werden.

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

Radiale & konische Gradients

radial-gradient strahlt von einem Zentrum nach außen — nützlich für Spotlights und Buttons. Das Zentrum ist positionierbar (at top left), Form/Größe steuerbar (circle, closest-side). conic-gradient rotiert Farben um einen Punkt — perfekt für Kreisdiagramme und Farbräder. Harte Stops in conic gradients erzeugen saubere Kuchenstücke.

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

background-clip steuert, wie weit der Hintergrund reicht: border-box (Default, unter dem Rahmen), padding-box (innerhalb des Rahmens) oder content-box (innerhalb des paddings). Der Headline-Trick: background-clip: text mit color: transparent füllt Text mit einem Gradient oder Bild. Für Safari immer die -webkit--Präfix-Version mitliefern. background-origin setzt den Positionierungsbereich.

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

background-attachment & Parallax

background-attachment: fixed erzeugt einen Parallax-Effekt — der Hintergrund bleibt fix, während der Inhalt darüber scrollt. scroll (Default) bewegt sich mit dem Element; local scrollt mit dem Inhalt des Elements (praktisch für scrollbare Boxen). fixed attachment ist ruckelig und auf Mobile schlecht unterstützt; für Produktions-Parallax besser transform: translate3d je Scrollposition.

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

Rahmen & abgerundete Ecken

border-radius

border-radius rundet Ecken, mit 1-4 Werten (im Uhrzeigersinn ab oben links). Ein Slash trennt horizontale/vertikale Radien für elliptische Ecken. border-radius: 50% macht aus einem Quadrat einen perfekten Kreis; aus einem Rechteck eine Ellipse. Einzelne Ecken steuert man über die Langform (border-top-left-radius). Abgerundete Ecken schneiden Hintergrund, Rahmen und (mit overflow: hidden) Kindinhalte.

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 schneidet ein Bild in 9 Regionen und setzt die Ecken/Kanten als Rahmen ein. border-image-slice teilt das Quellbild; repeat steuert das Kacheln der Kanten. Ein moderner Trick: border-image mit einem linear-gradient und slice 1 für Gradient-Rahmen. Hinweis: border-image ersetzt border-style, also zuerst border-width setzen.

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

Mehrere Rahmen

CSS kann mehrere border-Eigenschaften nicht stapeln, aber es gibt Auswege. box-shadow mit null-offset und spread erzeugt knackige äußere Rahmen (funktioniert mit border-radius). outline zeichnet einen zweiten Rahmen außen, ignoriert aber border-radius. Ein pseudo-element gibt volle Kontrolle inklusive Radius. Jede Technik hat Abwägungen — je nach Bedarf an abgerundeten Ecken wählen.

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

Gradient-Rahmen

Gradient-Rahmen sind knifflig, weil border-image kein border-radius unterstützt. Die robuste Lösung: zwei Hintergründe schichten — eine Volltonfarbe auf padding-box geclippt und ein Gradient auf border-box geclippt, mit transparentem Rahmen. Das respektiert border-radius und funktioniert überall. Die einfachere border-image-Methode reicht, wenn keine runden Ecken nötig sind.

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 & focus-Stile

outline zeichnet außerhalb des Rahmens und wirkt sich nicht aufs Layout aus — ideal für focus-Indikatoren. outline-offset ergänzt einen Abstand. Wichtige Barrierefreiheits-Regel: niemals outline: none ohne sichtbaren Ersatz (etwa ein box-shadow-Ring). :focus-visible zeigt den Umriss nur für Tastaturnavigation (nicht Mausklick) — der moderne, nutzerfreundliche Ansatz für focus-Styling.

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

2D-Transforms

2D-transforms — translate, rotate, scale, skew — bewegen und verzerren Elemente, ohne das Layout zu berühren (Geschwister reflowen nicht). Kombinierte transforms wenden sich rechts nach links an, die Reihenfolge zählt: rotate vor translate bewegt entlang der gedrehten Achse. Weil transforms kein reflow auslösen, sind sie ideal für Animationen und GPU-beschleunigt.

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 setzt den Drehpunkt für transforms — Default ist die Elementmitte. Er akzeptiert keywords (top left), Pixel oder Prozent. Der Ursprung ändert Rotations- und Skalierungsverhalten drastisch: eine Karte, die um ihre Oberkante kippt, braucht transform-origin: top. Für 3D-transforms ist ein dritter z-Achsen-Wert angebbar.

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

3D-Transforms

3D-transforms ergänzen rotateX, rotateY, rotateZ, translateZ und scaleZ. perspective(n) muss als erste Transformationsfunktion (oder am parent) angewandt werden, um Tiefe zu aktivieren — kleinere Werte überzeichnen den 3D-Effekt. translate3d und scale3d sind GPU-beschleunigt und in Animationen performanter als ihre 2D-Gegenstücke.

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 & 3D-Raum

perspective definiert die Betrachterdistanz — kleiner = dramatischeres 3D. Am parent setzen, damit alle Kinder denselben Fluchtpunkt teilen. transform-style: preserve-3d lässt verschachtelte Elemente in einem gemeinsamen 3D-Raum leben (Pflicht für Würfel). backface-visibility: hidden verbirgt die Rückseite eines Elements — Kern des flip-card-Effekts.

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

Transforms animieren (Performance)

Immer transform und opacity animieren — sie sind GPU-beschleunigt und lösen weder layout (reflow) noch paint aus. top/left/width/margin zu animieren zwingt den Browser zu Layout-Neuberechnungen in jedem Frame — Jank. will-change: transform deutet dem Browser an, eine compositor layer vorzubereiten, aber Übergebrauch verschwendet Speicher. Kurz vor einer Animation setzen und danach entfernen.

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

Transitions

transition-Kurzfassung

transition: property duration timing-function delay. Der Default ist all 0s ease 0s — bloßes transition: 0.3s animiert also alle geänderten Eigenschaften. Für Performance und Kontrolle konkrete Eigenschaften listen. Mehrere transitions kommaseparieren. Die transition gehört auf den Default-Zustand des Elements (nicht :hover), damit auch die Rückanimation spielt.

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

Timing-Funktionen

Timing-Funktionen steuern die Beschleunigung. ease (Default) ist geschmeidig. ease-out fühlt sich in UI am reaktionsschnellsten an (schneller Start, langsames Ende). linear wirkt für die meisten Bewegungen unnatürlich. cubic-bezier(x1,y1,x2,y2) erlaubt eigene Kurven — Werte außerhalb 0-1 auf der y-Achse erzeugen overshoot/bounce. steps(n) macht diskrete Sprünge, praktisch für sprite-sheet-Animationen.

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

Mehrere & gestaffelte transitions

Verschiedene Eigenschaften können verschiedene Dauer und Verzögerungen haben — nützlich für choreografierte Effekte, bei denen eine Eigenschaft fertig wird, bevor die nächste startet. transition-delay erzeugt gestaffelte Eingänge für Listen; mit nth-child kombinieren, um jedes Item progressiv zu verzögern. Verzögerungen wirken auch beim Ausgang — Vorsicht: mitten in der Verzögerung rausgehovert, kann der Eingang plötzlich ruckartig erscheinen.

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

transitionierbare Eigenschaften

Manche Eigenschaften transistionieren geschmeidig; andere verursachen Jank. Die GPU-beschleunigten Stars sind transform, opacity und filter. Farben und box-shadow sind okay (lösen paint aus, nicht layout). width, height, margin, top, left zu transitionieren vermeiden — sie erzwingen Layout-Neuberechnung in jedem Frame. Für Größenänderungen lieber 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; }

transition-Trigger

Transitions triggern auf jede Eigenschaftsänderung: Pseudoklassen-Zustände (:hover, :focus, :checked), Klassenänderungen (durch JS ergänzt/entfernt) und media query-Änderungen. Sie interpolieren geschmeidig zwischen alt und neu. Transitions laufen in beide Richtungen (hinein/raus). Für komplexere, loopende oder mehrstufige Bewegung @keyframes-Animationen nutzen.

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

Animationen

@keyframes

@keyframes definiert die Sequenz einer Animation. Stops können Prozentwerte (0%, 50%, 100%) oder from/to (entspricht 0%/100%) sein. In einem Stop nicht gelistete Eigenschaften interpolieren zwischen den definierten Stops. Nur animierbare Eigenschaften (transform, opacity, Farben) wirken — display, position usw. nicht. @keyframes einmal definieren und über viele Elemente wiederverwenden.

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

animation-Kurzfassung

Die animation-Kurzfassung packt 8 Eigenschaften in dieser Reihenfolge: name duration timing-function delay iteration-count direction fill-mode play-state. Mindestens name und duration sind nötig. Hinweis: Zwei Zeitwerte sind mehrdeutig — der erste ist duration, der zweite delay. In Produktion lieber Langform oder partielle Kurzfassung fürs Lesen.

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

Iteration & Richtung

animation-iteration-count steuert die Wiederholung — infinite läuft endlos, Bruchwerte spielen Teilzyklen. animation-direction: alternate spielt die Animation vorwärts und in der nächsten Iteration rückwärts — nahtloser Bounce. reverse spielt rückwärts, alternate-reverse startet rückwärts. alternate ist Pflicht für Ping-pong-Bewegungen wie Puls- oder Atmungs-Effekte.

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 steuert Stile vor und nach dem Animationslauf. none (Default) kehrt zu den normalen Stilen des Elements zurück. forwards hält nach dem Ende den finalen keyframe-Zustand — Pflicht für Eingangsanimationen, damit Elemente nicht zurückschnappen. backwards wendet den ersten keyframe während der Verzögerung an. both deckt beides ab. forwards oder both für Einmal-Eingänge nutzen.

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 & Pausieren

animation-play-state: paused friert eine Animation am aktuellen Frame ein; running setzt fort. Der sauberste Weg, bei Hover oder über eine JS-gekoppelte Klasse zu pausieren — die Animation merkt sich ihre Position statt neu zu starten. Für Performance Animationen von Elementen pausieren, die aus dem Blick scrollen, via IntersectionObserver. Mit reduced-motion-media queries für Barrierefreiheit kombinieren.

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

Grundlegende Syntax

Media queries wenden Stile bedingt an. (min-width: 768px) ist mobile-first — greift auf Screens ab 768px. Kombinieren mit and (beide müssen passen), Kommas (ODER) und not (negieren). Der mobile-first-Ansatz (min-width) wird bevorzugt: Basis-Stile für kleine Screens schreiben, dann für größere aufstocken. So bleibt das kleine-Screens-CSS schlank.

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

Min/Max-Width-Breakpoints

Breakpoints sollten am Inhalt orientieren, nicht an konkreten Geräten, aber gängige Bereiche funktionieren gut: 640px (Tablet), 1024px (Desktop), 1280px (groß). Mobile-first heißt min-width nutzen und mobile Stile als Basis schreiben. Die neuere range-Syntax (width >= 768px) ist lesbarer und in allen modernen Browsern unterstützt, ersetzt umständliche min/max-Kombinationen.

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

Orientierung & Seitenverhältnis

Neben width können media queries orientation (portrait/landscape), aspect-ratio, hover-Fähigkeit und pointer-Typ zielen. @media (hover: hover) stellt sicher, dass hover-Stile nur auf Geräten mit echtem pointer greifen (vermeidet sticky hover auf Touch). (pointer: coarse) zielt auf Touch-Geräte — perfekt, um Tap-Ziele zu vergrößern. Diese Features ermöglichen wirklich geräteangemessene Interfaces.

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

Print-Stile

Print-media queries stylen, wie Seiten beim Drucken aussehen. Navigation, Werbung und interaktive Elemente verbergen; Inhalt auf volle Breite dehnen; Schwarz-auf-Weiß für Tinteneffizienz erzwingen. break-inside: avoid verhindert, dass Elemente über Seiten splittern, und break-before: page erzwingt Umbrüche. Der ::after-Trick an Links offenbart URLs im Druck — unbezahlbar für druckbare Artikel.

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

prefers-reduced-motion ist ein kritisches Barrierefreiheits-Feature — Nutzer mit Vestibular-Störungen brauchen minimalisierte Bewegung. Immer einen reduced-motion-Fallback liefern, der Animationen deaktiviert oder verkürzt. prefers-color-scheme erlaubt automatische Anpassung an das OS-Theme des Nutzers. Beim dark mode auch Kontrast, Bilder und Schatten berücksichtigen, die auf dunklen Hintergründen funktionieren.

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

Responsives Design

Flüssige Typografie mit clamp()

clamp(min, preferred, max) erzeugt Werte, die zwischen Grenzen flüssig skalieren — perfekt für Typografie und Abstände, die sich ohne media queries anpassen. Der preferred-Wert ist meist ein vw-basierter Ausdruck. Das eliminiert viele Breakpoints. Mit rem paaren für Barrierefreiheit (Nutzer können die root font-size weiter skalieren). Flüssige Typografie verbessert wahrgenommene Performance und Lesbarkeit über Geräte hinweg.

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

Mobile-first-Ansatz

Mobile-first heißt, kleine-Screens-Stile als Basis schreiben und mit min-width-media queries für größere Screens aufstocken. Das ergibt schlankeres CSS (mobile lädt nur, was es braucht) und erzwingt inhaltspriorisiertes Denken. Desktop-first (max-width) zwingt mobile Geräte, Desktop-Stile zu laden und zu übersteuern — langsamer und schwerer zu pflegen.

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 sind ein Game-Changer: Komponenten reagieren auf die Größe ihres parents statt auf den viewport. Eine Karte passt ihr Layout an, ob sie in einer schmalen Seitenleiste oder einer breiten Hauptfläche sitzt — echte Komponenten-Responsiveness. container-type: inline-size fragt width ab (am performantesten). Container benennen, um sie gezielt anzusprechen, oder unbenannte queries für den nächsten Vorfahren nutzen.

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

Viewport-Einheiten

vh/vw sind Prozent des viewports. Das Problem: 100vh auf Mobile schwankt, wenn die Adressleiste ein-/ausgeblendet wird — Jank. Die neueren svh/lvh/dvh-Einheiten beheben das — dvh aktualisiert sich dynamisch, svh nutzt den kleinsten stabilen Wert. vmin/vmax sind die kleinere/größere viewport-Dimension — super für skalierende quadratische Elemente. vw-Font-Größen immer mit einem rem/px-Floor via calc oder clamp paaren.

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 hält automatisch ein width:height-Verhältnis — kein padding-top-Hack mehr für responsives Video. Die Höhe des Elements leitet sich aus der Breite ab (oder umgekehrt). Kombiniert mit object-fit: cover auf Bildern verhindert das layout shift beim Laden der Bilder. Der sauberste Weg, für Medien Platz zu reservieren und cumulative layout shift (CLS) zu vermeiden — ein 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 (Variablen)

Variablen definieren & nutzen

CSS custom properties (Variablen) werden mit --name deklariert und mit var(--name) genutzt. Auf :root definieren für globalen Zugriff oder auf ein beliebiges Element scopen. Anders als Präprozessor-Variablen sind sie live: eine Variable zu ändern aktualisiert alle Nutzungen in Echtzeit, und sie kaskadieren und erben. var() akzeptiert einen fallback als zweites Argument, greift, wenn die Variable undefiniert ist.

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

Theming & dark mode

Custom properties machen theming trivial: semantische Variablen definieren (--bg, --text, --primary), dann in einem [data-theme]-Selektor übersteuern. Das data-theme-Attribut auf <html> zu togglen tauscht das gesamte Theme sofort — keine duplizierten Stylesheets. Mit prefers-color-scheme kombinieren für automatischen dark mode, der eine manuelle Nutzerwahl respektiert. Der moderne, performante Weg zum theming.

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

Kaskadierung & Vererbung

Custom properties kaskadieren und erben wie normales CSS. Eine Variable auf .card ist für .card und alle Nachfahren verfügbar — aber nicht für Geschwister. Jedes Element liest den berechneten Wert der Variable in seinem eigenen Scope. @property (neuer) erlaubt das Deklarieren typisierter Variablen mit syntax, initial value und inheritance-Flag — ermöglicht geschmeidige transitions und Animationen von 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;
}

JavaScript-Interaktion

CSS-Variablen sind voll über JavaScript erreichbar. Lesen mit getComputedStyle(el).getPropertyValue('--name') (gibt einen String zurück, oft mit führendem Leerzeichen — trimmen). Setzen mit el.style.setProperty('--name', value). So werden custom properties zur mächtigen JS-zu-CSS-Brücke: eine Variable in JS ändern und CSS reagiert sofort — perfekt für scroll-getriebene Effekte, theming und dynamische Layouts.

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 & Verkettung

var() unterstützt einen fallback als zweites Argument, greift aber nur, wenn die Variable undefiniert ist (nicht bei ungültigen Werten — invalid macht die ganze Eigenschaft zu ihrem Default). Fallbacks verketten: var(--a, var(--b, #default)). Nützlich für progressive enhancement und Third-Party-Komponenten. @supports (--x: 0) erkennt Support, obwohl alle modernen Browser custom properties unterstützen.

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

Filter

Filter-Funktionen

filter wendet visuelle Effekte auf ein Element an. brightness/contrast/saturate nehmen Multiplikatoren (1 = normal) oder Prozent. hue-rotate verschiebt alle Töne um einen Winkel. Mehrere filter verketten sich links nach rechts. Häufig: Bilder bei Hover ausgrauen, Vintage-Photo-Effekte oder Hintergründe abdunkeln. filter wirkt auf das Element, seinen Hintergrund, Rahmen und Kinder.

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 ist das filter-Gegenstück zu box-shadow — folgt aber der tatsächlichen alpha-Form des Elements, nicht seiner Box. Schatten umschmiegen also PNG/SVG-Ausschnitte und unregelmäßige Formen. Für Icon-Schatten, glühende Logos oder jedes nicht-rechteckige Element. Mehrere drop-shadows schichtbar. Hinweis: teurer als box-shadow, also mit Bedacht einsetzen.

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 wendet einen filter auf alles hinter einem Element an — das Signaturmerkmal des glassmorphism. Ein halbtransparenter Hintergrund plus backdrop-filter: blur() erzeugt den Milchglas-Look. Für Safari immer das -webkit--Präfix mitliefern. Das Element braucht etwas Transparenz im Hintergrund, damit der Effekt sichtbar wird. Mit saturate() kombinieren für satte Ergebnisse und einen dezenten Rahmen zur Simulation von Kantenreflexionen ergänzen.

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

Filter kombinieren

Mehrere filter wirken links nach rechts, die Reihenfolge beeinflusst das Ergebnis (grayscale vor hue-rotate lässt nichts mehr zu rotieren). Filter sind animierbar und GPU-beschleunigt — super für hover-Effekte. filter mit mix-blend-mode paaren, um ein Element mit seinem backdrop zu verschmelzen. Für dynamische Kontrolle die filter-Kette in einer custom property speichern und via JS aktualisieren.

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

Filter-Performance

Filter sind GPU-beschleunigt, aber nicht gratis. Große blurs auf vollflächigen Elementen verursachen schwere repaints und Jank, besonders auf Mobile. blur-Radien klein halten, den gefilterten Bereich begrenzen und will-change: filter vor dem Animationsstart setzen. backdrop-filter ist besonders teuer — nur auf kleinen UI-Elementen, nicht auf ganzen Abschnitten. contain: paint isoliert den repaint-Bereich für bessere Performance.

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-elemente

::before & ::after

::before und ::after fügen generierten Inhalt vor/nach dem tatsächlichen Inhalt eines Elements ein. Die content-Eigenschaft ist Pflicht (auch ein leerer String für dekorative Elemente). Inhalt kann Text, escaped Unicode oder Attributwerte via attr() sein. Diese pseudo-elements defaulten auf inline — display: block für box-artige Dekoration setzen. Perfekt für Icons, dekorative Linien, Zitate und clearfix.

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 & ::first-line

::first-letter stylt das erste Zeichen — perfekt für Initialen in Artikeln. ::first-line stylt die erste formatierte Zeile, die sich dynamisch anpasst, wenn sich die viewport-Breite ändert. Beide wirken nur auf block-level-Elemente. ::first-letter greift nur, wenn vor dem ersten Zeichen kein anderer Inhalt steht (etwa Bilder). Typografie-Grundausstattung für redaktionelle Layouts.

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 stylt den von Nutzern markierten Text. Nur eine Handvoll Eigenschaften greifen: color, background-color, text-shadow und text-decoration. Damit die Auswahl-Farbe zur Marke passend stylen. Global mit ::selection anwenden oder auf konkrete Elemente scopen. Älteres Firefox brauchte ::-moz-selection, modernes Firefox unterstützt das standardkonforme ::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 & ::marker

::placeholder stylt den Platzhaltertext in Formularfeldern — opacity: 1 setzen, weil Firefox default einen durchscheinenden Platzhalter nutzt. ::marker stylt bullets oder Nummern von list-items und unterstützt eine begrenzte Eigenschaftsmenge (color, content, font, direction). Bullets durch eigenen content ersetzbar (Unicode, counters). Diese pseudo-elements bringen Formular- und Listenstyling voll unter Designer-Kontrolle.

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

Generierter Inhalt & counters

Generierter Inhalt via ::before/::after kann counter()-Werte, Attributwerte (attr()) oder String-Literale enthalten — ermöglicht reines CSS-Nummerieren, Icons und tooltips ohne Extra-DOM. counters() liefert verschachtelte Nummerierung wie '1.2.3'. Mit attr(data-tooltip) und einer hover-transition gebaute tooltips sind eine leichtgewichtige Alternative zu JS-Bibliotheken. Bedenken: generierter Inhalt ist nicht im DOM und wird von manchen Screenreadern nicht gelesen — kritischen Inhalt nicht dort ablegen.

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 & counter-increment

CSS counters nummerieren Elemente ohne JavaScript. counter-reset initialisiert einen counter (Default 0, aber jeder Startwert möglich). counter-increment erhöht ihn (Default 1, jede Ganzzahl möglich — auch negativ). Den Wert mit counter() innerhalb von content anzeigen. Counters sind auf das Element begrenzt, auf dem sie zurückgesetzt wurden, und seine Nachfahren — verschachtelte Nummerierung entsteht.

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

counter()-Funktion

counter(name) gibt den aktuellen Wert eines counters aus, und counter(name, style) wendet einen listen-Stil an: decimal (Default), lower/upper-alpha, lower/upper-roman, disc, square und mehr. Mehrere counters parallel führen und in content kombinieren — perfekt für Abbildungen, die pro Kapitel nummeriert sind (Figure 3-2). Counter-Werte werden zur Renderzeit berechnet und aktualisieren sich automatisch bei DOM-Änderungen.

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

Verschachtelte counters mit counters()

counters(name, separator) ist die verschachtelte-counter-Funktion: sie verkettet den counter-Wert über jeden Vorfahren-Scope, getrennt durch den gegebenen String. So entstehen Gliederungen wie '1.2.3' automatisch — derselbe counter-Name wird je verschachteltem <ol> zurückgesetzt. Ohne counters() (Plural) würden verschachtelte Listen dieselbe Nummerierung teilen. Der separator kann ein beliebiger String sein, wie '.' oder '-'.

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

counter-Styling

Counters unterstützen viele eingebaute Stile: decimal, upper-roman, lower-alpha, lower-greek, cjk-decimal und mehr. @counter-style erlaubt eigene Stile mit Symbol-Menge, system (cyclic, additive, extends) und Optionen wie pad (führende Nullen), prefix/suffix und range. Ideal für thematisierte Listen, Emoji-Bullets oder lokalisierte Nummerierung ohne 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, ... */
}

Praktische counter-Muster

Counters glänzen bei nummerierten Schritt-Indikatoren, Inhaltsverzeichnissen und Gliederungen. Das ::before mit rundem badge, Farbe und Zahl stylen erzeugt nummerierte Schrittlisten ohne manuelle Nummerierung. DOM bearbeiten und die Zahlen aktualisieren sich automatisch. Achtung: counter-Werte sind von JavaScript schwer lesbar — nur zur Anzeige. Für Logik auf Basis von Zählungen lieber JS oder 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

Multi-column-Layout

column-count & column-width

Das multi-column-Layout fließt Inhalt in zeitungartige Spalten. column-count legt die Zahl fest; column-width lässt der Browser so viele 250px-Spalten anlegen, wie passen (responsiv ohne media queries). Die Kurzfassung columns nimmt count und/oder width. Multi-column ideal für langen Lesetext, aber Vorsicht: kurzer Inhalt kann ungleiche Spaltenhöhen erzeugen.

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

column-gap setzt den Abstand zwischen Spalten (wird inzwischen auch von flexbox und grid genutzt). column-rule zeichnet eine vertikale Trennlinie in den Abstand — das column-Gegenstück zu border mit derselben Kurzfassung. Die rule belegt keine zusätzliche Breite; sie sitzt zentriert im Abstand. Eine dezente Farbe nutzen, um Spalten abzugrenzen, ohne aufdringlich zu sein.

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 bricht ein Element über alle Spalten — perfekt für eine Magazin-artige Schlagzeile über die volle Breite, mit Spalten darüber und darunter. column-span: none (Default) lässt Inhalt durch die Spalten fließen. Es kann signifikantes reflow verursachen und hatte inkonsistente Unterstützung; gründlich testen. Am zuverlässigsten für Überschriften zwischen Spaltenblöcken.

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 & column breaks

Multi-column-Inhalte können Elemente unangenehm über Spalten splitten. break-inside: avoid hält ein Element (wie eine Karte oder ein figure) in einer Spalte intakt. break-before/break-after: column erzwingen Spaltenumbrüche. Die älteren page-break-*-Eigenschaften wirken als Aliase. Ein üblicher Hack war display: inline-block mit width: 100%, aber break-inside: avoid ist der moderne, korrekte Ansatz.

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 & Ausbalancieren

column-fill steuert, wie Inhalt sich über Spalten verteilt. balance (Default) gleicht Höhen an, sodass Spalten ungefähr zusammen enden — visuell ordentlich. auto füllt die erste Spalte vollständig, bevor die nächste beginnt, und verlangt eine feste Höhe; es entspricht dem Druckverhalten. Ausbalancierte Spalten sind für allgemeine Nutzung schöner; auto, wenn Inhalt streng von oben nach unten fließen soll.

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

Benutzeroberfläche

outline & Barrierefreiheit

Sichtbare focus-Indikatoren sind eine Barrierefreiheits-Pflicht. :focus-visible zeigt den Umriss nur für Tastaturnutzer (nicht Maus) — die Best-Practice für focus-Styling. Niemals outline: none ohne Ersatz setzen (etwa ein box-shadow-Ring). outline-offset ergänzt Luft zwischen Element und Umriss. Moderne Browser unterstützen abgerundete outlines über border-radius, das die outline-Form beeinflusst.

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 steuert, ob Nutzer ein Element durch Ziehen skalieren können. textarea ist default skalierbar; resize: none deaktiviert es. vertical/horizontal/both begrenzen die Richtung. Damit resize funktioniert, braucht das Element ein overflow anders als visible (overflow: auto oder hidden setzen). Nützlich für textareas, Code-Editoren oder jedes nutzeranpassbare Panel.

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

caret-color setzt die Farbe des blinkenden Cursors in editierbaren Elementen — kleines, aber feines Detail für gebrandete Formulare. user-select steuert, ob Text selektierbar ist: none deaktiviert (für UI-Steuerelemente), all selektiert das ganze Element per Klick (gut für Codeblöcke oder E-Mails), contain hält die Auswahl im Element. user-select: none auf body vermeiden — schadet der Barrierefreiheit.

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 & Formular-Styling

appearance: none entfernt das native OS-Styling von Formularsteuerelementen und erlaubt vollständiges CSS-Styling — Pflicht für konsistentes, browserübergreifendes Formulardesign. Nach dem Entfernen des nativen select-Pfeils ein eigenes background-image ergänzen. Eigene checkboxes nutzen appearance: none plus :checked für den Zustand. Für vollen Support immer mit -webkit-/-moz- präfixen. Gründlich über Browser hinweg testen — manche Steuerelemente (date, color) bleiben schwer vollständig umzustylbar.

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 & Scrollbar

scroll-behavior: smooth auf <html> lässt anchor-link-Klicks zum Ziel animieren statt springen — mit prefers-reduced-motion paaren, um es für sensible Nutzer zu deaktivieren. Eigene scrollbars: die standardkonformen scrollbar-width/scrollbar-color-Eigenschaften funktionieren in Firefox und modernem Chrome; die ::-webkit-scrollbar-pseudo-elements geben in WebKit/Blink feinere Kontrolle. Dezente eigene scrollbars polieren die UX scrollbarer Flächen.

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

Fortgeschrittene & moderne Features

Scroll Snap

Scroll snap erzeugt karussellartiges oder seitenweises Scrollen ohne JavaScript. scroll-snap-type: x/y + mandatory/proximity steuert Achse und Strenge. Kinder mit scroll-snap-align snappen zu start/center/end. mandatory erzwingt Snapping (gut für seitenweise Abschnitte); proximity snapt nur bei Nähe (sanfter, für Bildergalerien). Mit scroll-margin kombinieren, um snap-Punkte unter sticky headers zu versetzen.

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

object-fit steuert, wie ein <img> oder <video> seine Box füllt — das Medien-Gegenstück zu background-size. cover füllt die Box und crop't den Überhang; contain passt die ganzen Medien ein (mit möglichem Leerraum); fill dehnt (verzerrt). object-position setzt den Brennpunkt — nützlich, wenn cover wichtige Bildteile abschneidet. Das eliminiert background-image-Hacks für responsive Medien.

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 deutet dem Browser an, dass sich eine Eigenschaft bald ändern wird, damit er GPU-Layer vorab allokieren und optimieren kann. Kurz vor einer Animation anwenden und danach entfernen — dauerhafte Nutzung auf vielen Elementen verschwendet Speicher und kann die Performance schmälern. Nur Eigenschaften listen, die wirklich animiert werden (transform, opacity, filter). Übergebrauch triggert das Gegenteil der beabsichtigten Wirkung — also sparsam und bewusst.

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 sagt dem Browser, dass ein Element unabhängig vom Rest der Seite ist, und ermöglicht große Performance-Gewinne — Änderungen innerhalb eines enthaltenen Elements triggern keine Neuberechnung außerhalb. layout, paint, style und size sind die Isolationstypen. strict (alle vier, inkl. size) ist am stärksten. contain auf wiederkehrende widgets, listen-items oder Werbung anwenden, um reflow/repaint-Kosten zu begrenzen. size verlangt explizite Maße.

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 & gap universell

aspect-ratio hält ein width:height-Verhältnis auf jedem Element und verhindert layout shift beim Laden von Medien. gap (und seine Langformen row-gap/column-gap) ist das moderne Abstands-Werkzeug, das in flexbox, grid und multi-column wirkt — und die .item + margin + :last-child-Hacks eliminiert. Beide Features sind in modernen Browsern universell unterstützt und lösen gemeinsam zwei der häufigsten CSS-Schwierigkeiten: Medienverhältnisse halten und Items sauber beabstanden.

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.