CSS Container Queries in 2026: Bouw responsieve componenten zonder viewport-breakpoints
Leer hoe CSS-containerqueries responsieve componenten laten aanpassen aan hun beschikbare ruimte in plaats van aan het browserviewport. Bouw herbruikbare kaarten, gebruik benoemde containers en container-eenheden, en vermijd veelvoorkomende lay‑out‑ en compatibiliteitsproblemen.
CSS-containerqueries in 2026: Bouw responsieve componenten zonder viewport-breekpunten
Responsief webdesign is traditioneel gebouwd op media queries. Ontwikkelaars kiezen viewport-breekpunten en passen lay-outs aan voor telefoons, tablets en desktops. Dit werkt nog steeds goed voor lay-outs op paginaniveau, maar moderne componenten verschijnen vaak in vele contexten: volledige breedte secties, smalle sidebars, dashboards, modals en grids.
Een kaart op een 1.440 pixels brede desktop kan nog steeds maar 280 pixels beschikbaar hebben in een sidebar. Een viewport-breekpunt kan de ruimte van die component niet betrouwbaar beschrijven.
CSS-containerqueries latency componenten reageren op de grootte van een geschikte ancestor in plaats van alleen de viewport. Dit maakt ze vooral bruikbaar in herbruikbare designsystemen, WordPress-blockthemas, Joomla-modules en page builders.
Wat zijn CSS-containerqueries?
Een size-containerquery evalueert de afmetingen van een geselecteerde ancestor-container. Een component kan zijn interne lay-out veranderen wanneer de beschikbare ruimte een drempel overschrijdt.
Bijvoorbeeld, een kaart kan zijn bovenafbeelding boven de tekst weergeven wanneer het smal is, maar de afbeelding naast de tekst zetten wanneer de container minimaal 480 pixels breed is.
Media queries blijven bruikbaar voor paginawijde navigatie en voorkeuren van apparaten. Containerqueries lossen het aparte probleem van componentniveau responsiviteit op.
Media queries vs. containerqueries: visuele vergelijking en live demo
De illustratie vergelijkt de twee benaderingen. Schuif de slider om de beschikbare breedte van de kaart te veranderen. De demonstratie gebruikt een echte CSS-size-containerquery, niet een JavaScript-bestuurde lay-outwisseling.
Media queries vs. container queries
Responds to browser viewport width.
Responds to available component space.
Try the 480px container breakpoint
A reusable card that adapts to the space available.
Read the guideHorizontal layout at 520px
Move the slider to change the container width. The card switches layout at 480px. On narrow screens the maximum width is limited to the available space.
Het breekpunt hoort bij het ontwerp van de component, niet bij een bepaald apparaatencategorie. Op een smal telefoonscherm beperkt de demo de container tot de beschikbare viewport-breedte.
Stap 1: Bouw een semantische kaart
Begin met een kaart die kan verschijnen in een artikellijst, productaanbeveling of documentatie-index:
<div class="card-container">
<article class="content-card">
<img class="content-card__image"
src="/images/example.webp"
alt="A laptop on a desk"
width="640" height="400">
<div class="content-card__body">
<h2>Building Better Web Components</h2>
<p>Learn how modern CSS makes layouts more reusable.</p>
<a href="/guide">Read the guide</a>
</div>
</article>
</div>
Het outer element wordt de query-container. Het inner article is de descendant wiens presentatie verandert.
Dit verschil is belangrijk: een size-containerquery stijlt niet het queried element zelf. Het evalueert een ancestor-container en stijlt overeenkomstige descendants.
Stap 2: Schrijf een robuuste default lay-out
Begin met een lay-out die bruikbaar blijft zonder containerqueries:
.card-container {
width: 100%;
}
.content-card {
display: grid;
grid-template-columns: minmax(0, 1fr);
gap: 1rem;
padding: 1rem;
border: 1px solid #d9dee5;
border-radius: 12px;
background: #fff;
}
.content-card__image {
display: block;
width: 100%;
height: auto;
aspect-ratio: 8 / 5;
object-fit: cover;
border-radius: 8px;
}
.content-card__body {
min-width: 0;
}
De default image-above-text lay-out werkt in smalle ruimtes. De minmax(0, 1fr) grid track en min-width: 0 verminderen het risico dat lange inhoud overloopt.
Stap 3: Verklaar de query-container
Gebruik de container-type eigenschap:
.card-container {
container-type: inline-size;
}
De inline-size waarde staat size queries toe langs de inline-as, wat meestal overeenkomt met breedte in horizontale schrijfrichtingen.
Je kan ook tegenkomen:
.card-container {
container-type: size;
}
De size waarde ondersteunt beide assen maar introduceert strengere containment-eisen. Voor de meeste responsieve kaarten is inline-size een praktischer default.
Containment is belangrijk omdat browsers de containergrootte kunnen berekenen zonder circulaire afhankelijkheden van descendant-stijlen.
Stap 4: Voeg de responsieve regel toe
Verander de interne lay-out alleen wanneer de ancestor-container breed genoeg is:

@container (min-width: 480px) {
.content-card {
grid-template-columns: 180px minmax(0, 1fr);
align-items: center;
}
.content-card__image {
height: 100%;
}
}
Een brede desktopsidebar die slechts 300 pixels breed is, houdt de gestapelde lay-out. Een kaart in een 600-pixels contentkolom wordt horizontaal, zelfs als de viewport niet bijzonder breed is.
Dit is het centrale voordeel: het component reageert op zijn eigen beschikbare ruimte.
Stap 5: Gebruik named containers voor complexe lay-outs
In een dashboard of CMS-sjabloon kan een component meerdere geneste containers hebben. Standaard vindt een size query de dichtstbijzijnde geschikte ancestor.
Geef de bedoelde container een naam wanneer je meer controle nodig hebt:
.article-list-item {
container: article-card / inline-size;
}
@container article-card (min-width: 480px) {
.content-card {
grid-template-columns: 180px minmax(0, 1fr);
}
}
De container shorthand definieert zowel de naam als het type. Namering helpt voorkomen dat een ongerelateerde geneste container het query-doel wordt.
Stap 6: Gebruik container-relatieve units
CSS bevat length units gebaseerd op een geschikte query-container:
| Unit | Betekenis |
|---|---|
cqw |
1% van containerbreedte |
cqh |
1% van containerhoogte |
cqi |
1% van container inline size |
cqb |
1% van container block size |
cqmin |
Kleiner van cqi en cqb |
cqmax |
Groter van cqi en cqb |
Voor vloeiende componenttypografie:
.card-container {
container: article-card / inline-size;
}
.content-card h2 {
font-size: clamp(1.1rem, 4cqi, 1.8rem);
}
In tegenstelling tot vw, kan cqi tekst schalen met de container van het component. Test altijd leesbaarheid, browserzoom en lange vertaalde koppen. Als er geen geschikte container bestaan, volgen container-relatieve units het opgegeven fallback-gedrag in plaats van ongültig te worden.
Stap 7: Voeg progressieve verbetering toe
Houd de default gestapelde lay-out en schakel de geavanceerdere functionaliteit conditioneel in:
.content-card {
display: grid;
grid-template-columns: 1fr;
}
@supports (container-type: inline-size) {
.card-container {
container-type: inline-size;
}
@container (min-width: 480px) {
.content-card {
grid-template-columns: 180px minmax(0, 1fr);
}
}
}
Browsers zonder de relevante functionaliteit behouden een functionele lay-out. De fallback hoeft niet elke verbetering te evenaren; hij moet alleen leesbaar en bruikbaar blijven.
Containerqueries vervangen Grid of Flexbox niet
Grid en Flexbox rangschikken elementen. Containerqueries bepalen wanneer bepaalde CSS-regels van toepassing zijn.
Bijvoorbeeld, een responsieve verzameling kaarten hoeft alleen maar Grid te gebruiken:
.product-grid {
display: grid;
grid-template-columns:
repeat(auto-fit, minmax(min(100%, 240px), 1fr));
gap: 1.5rem;
}
Voeg containerqueries toe wanneer de interne ontwerp van elke kaart moet veranderen op basis van de toegewezen breedte. Vermijd het introduceren van query-containers waar standaard Grid of Flexbox het probleem al oplost.
Wat over container style queries?
Containerqueries kunnen ook enkekele berekende style-condities testen, inclusief custom properties in ondersteunende browsers:
.feature-panel {
--panel-theme: dark;
}
@container style(--panel-theme: dark) {
.feature-panel__title {
color: white;
}
}
Deze illustreert de syntaxis; style queries en nieuwere query-mogelijkheden hebben aparte browserondersteuning. Ondersteuning voor size queries garandeert niet ondersteuning voor elke style query, eigenschap of nieuwere scroll-state functionaliteit. Controleer de exacte functionaliteit aan de huidige compatibiliteitstabels voordat je in productie gaat.
Vijf veelvoorkomende fouten
1. Het queryen van de eigen grootte van een element om het zelf te stijlen

Dit werkt niet als bedoeld:
.card {
container-type: inline-size;
}
@container (min-width: 480px) {
.card {
display: grid;
}
}
De queried container moet een ancestor zijn van het gestylde element. Voeg een outer wrapper toe of verplaats de containment naar een geschikte ancestor.
2. Vergeten een container te declareren
Een @container regel alone maakt automatisch de dichtstbijzijnde parent een geschikte size container. Declareer container-type: inline-size of use de overeenkomstige shorthand.
3. Blindelijks hergebruiken van viewport-breekpunten
Gebruik niet automatisch 768px of 1024px alleen maar omdat die getallen bekend zijn. Kies een breekpunt waar de inhoud van het component daadwerkelijk een andere rangschikking nodig heeft.
4. Containment overal toepassen
Containment verandert het gedrag van sizing. Teveel containers kunnen het opsporen bemoeilijken, vooral wanneer een element afhankelijk is van descendants voor zijn dimensies. Richt containers met opzet in.
5. Aannemen dat elke container query functionaliteit gelijk ondersteund is
Size queries, style queries en nieuwere functionaliteit hebben verschillende compatibiliteitsgeschiedenissen. Controleer de exacte syntaxis die je wilt verzenden.
Prestatie-overwegingen
Containerqueries lopen in de browser's CSS/layout-engine. Ze kunnen enkele JavaScript-based resize observers en handmatige DOM-metingen elimineren.
Die architecturale vereenvoudiging is handig, maar containerqueries garanderen geen snellere website. De renderkosten afhankelijk van de stylesheet, DOM-complexiteit, lay-outstructuur en containment-keuzes.
Meet prestatie en vermijd onnodige query-lagen.
Praktische toepassingen in WordPress en Joomla
WordPress block themes: Hetzelfde block kan verschijnen in een volledige breedte sectie, een smalle kolom of een sidebar. Containerqueries latency het block aanpassen zonder aparte desktop- en mobile-varianten.
Joomla templates en modules: Een module kan worden toegewezen aan verschillende templateposities. Een component-based lay-out kan aanpassen aan de daadwerkelijke modulebreedte in plaats van te raden vanuit de viewport.
Page builders: Bewerkers verplaatsen regelmatig componenten tussen geneste koloms. Container-based rules kunnen deze componenten veerkrachtiger maken bij lay-outveranderingen.
Dashboards: Resizable panels en widgets kunnen hun interne lay-outs aanpassen wanneer de beschikbare ruimte verandert.
Wanneer moet je nog steeds media queries gebruiken?
Media queries blijven geschikt voor viewport-afhankelijke navigatie, printstijls, reduced-motion voorkeuren, pointer-capaciteiten en andere kenmerken van gebruiker/apparaat.
Een bruikbare richtlijn is media queries voor de pagina; containerqueries voor de component. Het is geen absolute regel, maar het is een duidelijke manier om verantwoordelijkheden te verdelen.
Hoe test je containerqueries
Test hetzelfde component in een breed contentgebied, smalle sidebar, grid en modal. Resize de container, niet alleen het browservenster.
Controleer horizontale overflow, afbeeldingsvervorming, lange titels, browserzoom, vertaalde inhoud en right-to-left schrijfrichtingen waar van toepassing.
Gebruik browser developer tools om berekende container-eigenschappen te inspecteren en te bevestigen welke regels van toepassing zijn. Test op daadwerkelijke smale apparaten alsook op desktop-simulaties.
Conclusie
CSS-containerqueries lossen een langstaand beperking van viewport-based responsive design op: de beschikbare ruimte van een component hoeft niet overeen te komen met de breedte van de browser.
Door size containers te combineren met Grid, Flexbox en sensibele fallbacks, kunnen ontwikkelaars herbruikbare componenten creëren die natuurlijk aanpassen over themas, modules, page builders en applicaties.
Begin met een functionele default lay-out, declareer alleen betekenisvolle containers, kies breekpunten op basis van inhoud en test in meerdere contexten.
Responsief design is niet langer alleen maar over de grootte van het scherm. Het is ook over de ruimte die beschikbaar is voor elk component.