History & Evolution of Tailwind
Trace Tailwind CSS's origin story from a side project in 2017 through the Just-In-Time compiler rewrite to today's v3 and v4 releases.
Introduction
Tailwind CSS is young compared to frameworks like Bootstrap, but in less than a decade it has reshaped how a huge portion of the industry writes CSS. Understanding its history — particularly the Just-In-Time compiler rewrite — helps explain design decisions you'll run into later, like why arbitrary values such as top-[117px] work at all, and why generated CSS files stay small no matter how large your project grows.
Origins
Tailwind CSS grew out of work Adam Wathan was doing on a project called Crema. He and his collaborators, Jonathan Reinink and Steve Schoger, had been refining an internal set of utility classes for their own client work. Adam publicly released Tailwind CSS as an open-source project in November 2017, with an accompanying blog post making the case for utility-first CSS at a time when the dominant advice was still 'never write styles in your markup.'
The framework's core idea wasn't entirely new — utility classes existed in various forms before Tailwind — but Tailwind's execution was different: a comprehensive, consistent, configurable design system expressed entirely as utilities, with a build step that generated exactly the CSS a project needed.
The Just-In-Time Compiler
Early versions of Tailwind worked by generating every possible utility class combination up front, then relying on a separate tool (PurgeCSS) to strip out anything unused before shipping to production. This worked, but it made local development slow — the full, unpurged CSS file could be tens of megabytes, and rebuilding it after every change wasn't instant.
In 2021, Tailwind introduced the Just-In-Time (JIT) compiler, which scans your actual source files and generates only the CSS for classes you've used, on demand, as you type. This was a turning point for the project: development builds became dramatically faster, previously impractical features like arbitrary value support (bg-[#1da1f2] or w-[137px]) became viable, and by Tailwind CSS v3 (released in 2021), the JIT engine became the default and only build strategy.
The JIT compiler is why Tailwind can support an effectively unlimited design space (any arbitrary value in square brackets) while still shipping a tiny CSS file — it only ever generates the exact classes your markup references.
Major Milestones
| Year | Release | Significance |
|---|---|---|
| 2017 | Tailwind CSS 0.x / 1.0 | Initial public release, utility-first CSS introduced to a wide audience |
| 2019 | Tailwind CSS 1.0 | First stable 1.0 release with a documented, configurable design system |
| 2020 | Tailwind UI launches | Official paid component library built on top of Tailwind |
| 2021 | JIT Compiler / v3 | Just-In-Time engine becomes the default, enabling arbitrary values and near-instant builds |
| 2022 | Tailwind CSS v3.0 | JIT-only architecture, dark mode variants, and an expanded default color palette |
| 2024 | Tailwind CSS v4.0 | Rewritten high-performance engine (Oxide), CSS-first configuration, and native cascade layers |
Tailwind Today
As of this course, Tailwind CSS v3 remains extremely widely deployed and is what most existing tutorials, courses, and production codebases use — including the examples throughout this course, since v3-style class names are still the most portable and widely recognized syntax. Tailwind CSS v4, released more recently, keeps the same utility-first philosophy but moves configuration into CSS itself (via an @theme block) instead of a JavaScript config file, and ships a much faster underlying engine. The two versions share the same core mental model — composing small utility classes — so skills transfer directly between them.
// A quick way to check your installed Tailwind versionnpm list tailwindcssClick Run to see what this code prints.
Common Mistakes
- Assuming Tailwind has always used the JIT compiler — it was introduced in 2021 and became default with v3.
- Mixing v3 and v4 setup instructions — the configuration approach (JS config file vs. CSS-first @theme) differs between them.
- Thinking Tailwind UI is required to use Tailwind CSS — it's an optional, separate paid product, not a dependency.
- Believing purging unused CSS is something you must set up manually today — it has been automatic and built-in since the JIT compiler landed.
Best Practices
- Check which major version a tutorial or Stack Overflow answer targets before copying configuration syntax.
- Read the official upgrade guide before moving an existing project between major versions.
- Understand that arbitrary value syntax like p-[13px] exists because of the JIT compiler — it won't work the same way in pre-JIT setups.
- When starting a brand-new project today, check the official docs for the currently recommended version and installation path.
Frequently Asked Questions
Adam Wathan created Tailwind CSS, with early contributions from Jonathan Reinink and Steve Schoger, and released it publicly in November 2017.
Before JIT, Tailwind generated every possible utility class upfront and relied on a separate purge step. JIT instead scans your source files and generates only the CSS you actually use, on demand — resulting in much faster builds and support for arbitrary values.
This course teaches v3-style class names, which remain the most widely used and recognized syntax across existing projects, documentation, and tutorials. The core utility-first concepts you learn transfer directly to v4.
No. Tailwind CSS is the free, open-source utility framework. Tailwind UI is a separate, paid library of pre-built component designs built using Tailwind CSS classes.
Key Takeaways
- Tailwind CSS was released publicly by Adam Wathan in November 2017.
- The Just-In-Time (JIT) compiler, introduced in 2021, generates only the CSS classes your project actually uses.
- Tailwind CSS v3 made the JIT engine the default and only build strategy.
- Tailwind CSS v4 introduced a CSS-first configuration model and a rewritten, faster engine, while keeping the same utility-first philosophy.
Summary
You've traced Tailwind from a 2017 side-project release to the JIT-powered, versionally mature framework it is today. Next, you'll look at why Tailwind specifically is worth learning — the productivity, consistency, and ecosystem reasons it has become so popular.