If you've ever added !important to a CSS rule just to override a third-party component's styles, you know the feeling. You know it's wrong. You know it'll come back to haunt you. But the alternative, writing an even more specific selector, feels just as bad.
CSS specificity has been the source of countless hours of frustration in frontend development. And while conventions like BEM and methodologies like ITCSS have helped, they're all workarounds for a fundamental problem in how CSS resolves conflicts.
That changed with CSS Cascade Layers.
What Are Cascade Layers?
Cascade Layers, introduced via the @layer rule, give you explicit control over which styles take priority — independent of selector specificity. You declare an order of layers, and CSS respects it. Period.
@layer reset, base, components, utilities;
@layer reset {
* { margin: 0; padding: 0; }
}
@layer components {
.button { color: blue; font-weight: bold; }
}
@layer utilities {
.text-red { color: red; }
}
In this example, .text-red will always override .button's color — not because it has higher specificity, but because the utilities layer is declared after components. No !important needed. No specificity hacks. The layer order is the single source of truth.
This is a game-changer for a few reasons:
- Third-party styles become manageable. Put your vendor CSS in an early layer, and your own styles will always win.
- Utility classes just work. Tailwind-style utilities in a later layer override component styles without needing specificity tricks.
- Team conventions become enforceable. The layer order is explicit and visible, not buried in selector complexity.
And the browser support is solid — Chrome 99+, Firefox 97+, Safari 15.4+, Edge 99+. If you're targeting modern browsers, you can use this today.
The Problem Layers Don't Solve
There's a catch, though. While the concept of layers is elegant, the practice of maintaining them in a real codebase gets messy fast.
Consider a typical project with hundreds of CSS or SCSS files spread across directories like components/, pages/, utilities/, and vendor/. To use layers, you'd need to:
- Wrap every CSS file in the appropriate
@layerblock - Keep a single
@layerorder declaration in sync with your architecture - Remember to wrap new files as you create them
- Handle edge cases like Sass
@usestatements that can't live inside a layer block
That's a lot of manual bookkeeping. And manual bookkeeping in CSS is exactly the kind of thing that breaks quietly and gets discovered in production.
Let Your Build Tool Do It
This is the kind of tedious, pattern-based work that build tools are perfect for. That's why I built css-layering-webpack-plugin (and later, a Vite equivalent).
The idea is simple: you define your layers with glob patterns, and the plugin wraps matching files in @layer blocks at build time. It also generates and injects the layer order declaration into your HTML automatically.
Here's what a typical configuration looks like:
{
layers: [
{ name: 'reset', path: '**/reset.css' },
{ name: 'base', path: '**/base/**/*.css' },
{ name: 'components', path: '**/components/**/*.css' },
{ name: 'utilities', path: '**/utilities/**/*.css' },
]
}
That's it. Every CSS file matching **/components/**/*.css gets wrapped in @layer components { ... }, and the plugin injects @layer reset, base, components, utilities; into your HTML <head>.
A few things happen automatically that you'd otherwise have to handle yourself:
-
Sass
@usestatements are preserved at the top of the file, outside the layer block (since Sass requires@useto come before any other rules). - The layer order declaration stays in sync with your configuration — add a layer, and it appears in the right place.
- First-match-wins behavior means files are only wrapped in the first matching layer, so overlapping patterns are predictable.
You can also exclude specific files from a layer, which is useful for incremental migration:
{
path: '**/components/**/*.css',
exclude: '**/components/legacy/**',
name: 'components'
}
Or define layers without a path to include manually-created layers in the order declaration:
{ name: 'third-party' } // No path — just reserves its spot in the layer order
Where This Shines
Here are some scenarios where automated layering really pays off:
You're integrating a design system. Your team uses a shared component library, and its styles keep clashing with your app's styles. Put the library in an early layer, and your app styles always win — without touching the library's code.
You're adopting utility-first CSS alongside existing component styles. Whether it's Tailwind or your own utility classes, putting them in a later layer means they'll override component styles as intended, without !important.
You're working on a large codebase with multiple teams. Layers make the CSS architecture explicit. A new developer can look at the layer configuration and immediately understand the intended specificity order.
You're migrating incrementally. You don't have to layer everything at once. Start by wrapping new code in layers while excluding legacy files. Over time, bring more files into the layered architecture.
Getting Started
The plugin is available for both major bundlers:
- Webpack: css-layering-webpack-plugin
- Vite: vite-plugin-css-layering
Both use the same configuration format, so the examples above work regardless of which bundler you're using. Install the one that matches your setup and add the layer configuration to your build config.
The layer order injection supports multiple strategies — inline <style> tags (the default), external <link> tags pointing to an emitted CSS file, or no injection at all if you prefer to manage the declaration manually.
A Note on AI usage
AI was used to create tests for the Webpack plugin. The plugin was ported to Vite using AI pretty effectively. This article was created with help from AI.
If you've been fighting specificity battles in your CSS, give Cascade Layers a try. And if you don't want to wrap every file by hand, let your build tool do it for you.