Purging unused styles in Tailwind - Deep Dive

Overview - Purging unused styles

What is it?

Purging unused styles means removing CSS rules that your website does not use. Tailwind CSS generates many utility classes, but not all are needed in every project. Purging helps keep the final CSS file small by deleting these unused classes. This makes your website faster and lighter to load.

Why it matters

Without purging, your website would load a huge CSS file full of styles you never use. This slows down the site, wastes bandwidth, and hurts user experience, especially on slow connections or mobile devices. Purging ensures only the styles you actually use are sent to the browser, making your site faster and more efficient.

Where it fits

Before learning purging, you should understand how Tailwind CSS works and how utility classes are applied in HTML. After mastering purging, you can explore advanced optimization techniques like code splitting and critical CSS for even better performance.

Mental Model

Core Idea

Purging unused styles is like cleaning out a closet by removing clothes you never wear, so only what you need stays and everything fits neatly.

Think of it like...

Imagine your CSS file as a big closet full of clothes (styles). Purging is like taking out all the clothes you never wear, leaving only your favorite outfits. This makes it easier to find what you need and keeps the closet tidy and light.

┌─────────────────────────────┐
│ Tailwind CSS generates many │
│ utility classes (clothes)   │
├─────────────┬───────────────┤
│ Used styles │ Unused styles │
│ (kept)      │ (removed)     │
└─────────────┴───────────────┘
         ↓ Purging process
┌─────────────────────────────┐
│ Final CSS file with only     │
│ used styles (light closet)  │
└─────────────────────────────┘

Build-Up - 7 Steps

1

Foundation

What is Tailwind CSS Purging

Concept: Introduction to the idea of removing unused CSS styles.

Tailwind CSS creates many utility classes for styling. However, not all these classes are used in your project. Purging is the process of scanning your files to find which classes you actually use and removing the rest from the final CSS file.

Result

You get a smaller CSS file that only contains styles your website uses.

Understanding purging helps you realize why your CSS file size can be huge without it and how removing unused styles improves performance.

2

Foundation

How Tailwind Generates CSS

Concept: Understanding Tailwind's utility-first approach and CSS generation.

Tailwind generates CSS classes for every possible utility you might use, like padding, margin, colors, and more. This means the initial CSS file is very large because it includes all these classes, even if you don't use them all.

Result

A very large CSS file before purging.

Knowing that Tailwind creates all possible styles explains why purging is necessary to keep your project efficient.

3

Intermediate

Configuring Purge in Tailwind

🤔Before reading on: Do you think purging happens automatically or needs setup? Commit to your answer.

Concept: How to tell Tailwind which files to scan for used classes.

In your Tailwind configuration file (tailwind.config.js), you specify the paths to your HTML, JavaScript, or template files. Tailwind scans these files to find class names you use and removes all others from the final CSS.

Result

Tailwind produces a CSS file containing only the classes found in your specified files.

Knowing how to configure purge paths is key to effective purging and avoiding accidentally removing needed styles.

4

Intermediate

Handling Dynamic Class Names

🤔Before reading on: Can Tailwind detect class names built dynamically in code? Commit to yes or no.

Concept: Understanding limitations of purging with dynamic or conditional class names.

Tailwind's purge scans static class names in your files. If you build class names dynamically (like using string concatenation or variables), Tailwind might miss them and remove those styles. To fix this, you can use the 'safelist' option to keep specific classes or write class names explicitly.

Result

Properly preserved styles even when using dynamic class names.

Recognizing purging's limits with dynamic classes helps prevent bugs where styles disappear unexpectedly.

5

Intermediate

Using Safelist to Preserve Styles

Concept: How to keep certain classes from being purged even if not found in files.

Tailwind allows you to define a safelist in the config file. This is a list of class names or patterns that should never be removed during purging. This is useful for classes added dynamically or by JavaScript at runtime.

Result

Safelisted classes remain in the final CSS file regardless of usage detection.

Knowing about safelist prevents accidental removal of important styles and keeps your UI consistent.

6

Advanced

Purging in Production Builds

🤔Before reading on: Do you think purging should be enabled during development or only in production? Commit to your answer.

Concept: Best practices for when and how to run purging in your workflow.

Purging is usually enabled only in production builds to keep development fast and flexible. During development, you keep all styles to avoid missing any. When building for production, purging removes unused styles to optimize performance.

Result

Fast development experience and optimized production CSS size.

Understanding when to purge balances developer convenience with user experience.

7

Expert

Advanced Purge Optimization Techniques

🤔Before reading on: Can purging alone guarantee the smallest CSS? Commit to yes or no.

Concept: Going beyond basic purging to further optimize CSS size and loading speed.

Experts combine purging with techniques like extracting critical CSS (styles needed immediately), lazy loading styles, and integrating with tools like PostCSS or PurgeCSS plugins. They also carefully manage safelists and dynamic classes to avoid bloating CSS.

Result

Highly optimized CSS that loads quickly and only contains necessary styles.

Knowing advanced optimization techniques helps build lightning-fast websites and avoid common pitfalls of purging.

Under the Hood

Tailwind's purge process scans your source files for class names by reading the text content. It matches these names against the full set of generated utility classes. Classes not found in the scan are excluded from the final CSS output. This scanning happens during the build step, not at runtime, so the browser only receives the minimal CSS needed.

Why designed this way?

Tailwind was designed to generate a huge set of utility classes upfront for flexibility. Purging was introduced to solve the problem of large CSS files by removing unused styles after development. This approach balances developer experience with performance, avoiding the need to manually write or maintain CSS.

┌───────────────┐       ┌───────────────┐       ┌───────────────┐
│ Source files  │──────▶│ Purge process │──────▶│ Final CSS file │
│ (HTML, JS)   │       │ scans classes │       │ with used only │
└───────────────┘       └───────────────┘       └───────────────┘

Myth Busters - 4 Common Misconceptions

Quick: Does purging remove styles at runtime in the browser? Commit yes or no.

Common Belief: Purging removes unused styles dynamically when the page loads in the browser.

Reality: Purging happens during the build process before deployment, not in the browser at runtime.

Why it matters: Thinking purging happens in the browser can confuse debugging and lead to wrong assumptions about CSS behavior.

Quick: Can Tailwind detect all class names even if built dynamically? Commit yes or no.

Common Belief: Tailwind's purge can find and keep all classes, even those created dynamically in code.

Reality: Tailwind's purge only detects static class names in files. Dynamic or computed class names may be missed and removed unless safelisted.

Why it matters: Missing dynamic classes causes broken styles in production, leading to UI bugs.

Quick: Is purging optional for small projects? Commit yes or no.

Common Belief: For small projects, purging is not necessary because CSS files are already small.

Reality: Even small projects benefit from purging because Tailwind's base CSS is large. Purging always reduces file size and improves load speed.

Why it matters: Skipping purging can slow down sites unnecessarily, especially on mobile or slow networks.

Quick: Does purging remove styles used only in JavaScript? Commit yes or no.

Common Belief: Purging always keeps styles used anywhere, including those added by JavaScript at runtime.

Reality: Purging only scans source files, so styles added dynamically by JavaScript can be removed unless explicitly safelisted.

Why it matters: Not safelisting dynamic styles causes missing styles and broken UI after deployment.

Expert Zone

1

Purging can accidentally remove styles used in third-party libraries if their class names are not present in your source files, requiring careful safelisting.

2

The order of safelisting patterns matters; more specific patterns should come before general ones to avoid unintended style retention.

3

Tailwind's JIT mode changes purging behavior by generating styles on-demand, reducing the need for traditional purging but requiring different configuration.

When NOT to use

Purging is not suitable during active development because it slows down build times and can remove styles you are still experimenting with. Instead, use it only in production builds. For projects with highly dynamic styling or runtime-generated classes, consider using safelists or alternative CSS-in-JS solutions that handle dynamic styles better.

Production Patterns

In production, purging is integrated into build pipelines using tools like Webpack, Vite, or PostCSS. Teams often combine purging with minification and compression to deliver the smallest CSS. Large projects use safelists extensively to protect dynamic styles and integrate purging with component-based frameworks to scan all relevant files.

Connections

Tree Shaking in JavaScript

Both remove unused code to optimize final output.

Understanding purging as CSS's version of tree shaking helps grasp the importance of removing unused parts for performance.

Garbage Collection in Programming

Both clean up unused resources to keep systems efficient.

Seeing purging like garbage collection clarifies how removing unused styles prevents waste and keeps the website lean.

Minimalism in Design

Purging applies minimalism by keeping only what is necessary.

Knowing minimalism principles helps appreciate why removing unused styles improves clarity and speed.

Common Pitfalls

#1 Purging removes styles used dynamically by JavaScript, breaking the UI.

Wrong approach:

module.exports = {
content: ['./src/**/*.html'],
// no safelist defined
};

Correct approach:

module.exports = {
content: ['./src/**/*.html', './src/**/*.js'],
safelist: ['dynamic-class-name'],
};

Root cause:

Not including all source files or safelisting dynamic classes causes purging to remove needed styles.

#2 Enabling purging during development slows down build and causes confusion.

Wrong approach:

module.exports = {
content: ['./src/**/*.{html,js}'],
purge: true, // purging always on
};

Correct approach:

module.exports = {
content: ['./src/**/*.{html,js}'],
purge: process.env.NODE_ENV === 'production',
};

Root cause:

Purging is resource-intensive and should only run in production to keep development fast.

#3 Not specifying correct file paths in purge config leads to missing styles.

Wrong approach:

module.exports = {
content: ['./public/index.html'],
};

Correct approach:

module.exports = {
content: ['./public/index.html', './src/**/*.{js,jsx,ts,tsx,vue}'],
};

Root cause:

Incomplete content paths cause Tailwind to miss classes used in other files.

Key Takeaways

Purging unused styles removes all CSS classes you don't use, making your website faster and lighter.

Tailwind generates many utility classes by default, so purging is essential to keep CSS size manageable.

Purging happens during the build process by scanning your source files for used class names.

Dynamic or JavaScript-generated class names need special handling with safelists to avoid accidental removal.

Proper purging configuration and timing (usually only in production) balance developer experience and site performance.