tailwindlabs/tailwindcss

This system is the core engine and distribution infrastructure for Tailwind CSS v4, a utility-first CSS framework. It provides a high-performance, Rust-based content scanner and CSS compiler that replaces previous JavaScript implementations to accelerate build times. The codebase also includes a comprehensive suite of integration packages for major build tools like Vite, Webpack, and PostCSS, alongside a CLI tool and an automated upgrade utility for migrating projects from version 3.

47 changes.

This period centered on the development and release of Tailwind CSS v4, featuring a complete architectural overhaul that replaced the PostCSS pipeline with a custom Rust-based engine (Oxide) for significantly faster builds. The work involved stripping legacy LESS styles and utilities to adopt a new CSS-first configuration model, while simultaneously introducing dedicated plugins for Vite and PostCSS, a standalone CLI, and automated upgrade tools to facilitate migration from v3.

19 changes.

This period focused on developing the Tailwind CSS v4 upgrade infrastructure, including comprehensive codemods for migrating configuration, CSS, and templates from v3. It also introduced a new browser-based runtime package for client-side compilation and significantly rewrote the core class-name extraction engine to support a wider range of template languages and syntaxes.

Introduces the initial structure for the \crates/node\ location, including a \.gitignore\ covering Node, macOS, Windows, and Cargo artifacts, an \.npmignore\ for publishing, a \build.rs\ script to configure \napi\_build\, and a \rustfmt.toml\ for code formatting.

crates/node · high confidence

A new Vite-based playground has been added to demonstrate the Tailwind CSS v4 codebase. This setup includes a React application that imports the new \@import 'tailwindcss'\ directive in its CSS, allowing users to test v4 features like the new plugin system and utility generation within a Vite environment.

playgrounds/vite · high confidence

The Tailwind CSS CLI now includes a new \canonicalize\ subcommand that processes CSS class names (candidate groups) to collapse equivalent classes, sort them, and output the canonical form. Users can provide classes as positional arguments or pipe them via stdin using the new \--stream\ flag. The command supports multiple output formats—text, JSON, and JSONL—via the \--format\ option, and allows specifying a custom CSS entry file with \--css\ to load the design system.

packages/@tailwindcss-cli/src/commands/canonicalize · high confidence

A new internal example plugin has been added to the project, providing two custom CSS variants: 'inverted', which applies styles when the system prefers inverted colors, and 'hocus', which combines hover and focus states.

packages/internal-example-plugin · high confidence

Tailwind CSS now generates source maps that map the compiled output back to the original input files, including imported stylesheets. This enables developers to debug their CSS in browser devtools by seeing the original source locations for generated rules. The implementation includes a line-table utility for efficient offset-to-position lookups and a visualization tool for inspecting mappings.

packages/tailwindcss/src/source-maps · high confidence

The class extraction engine now includes dedicated pre-processors for a wide range of template and code languages, ensuring utility classes are correctly identified in Clojure keywords, Elixir sigils (charlists, word lists, strings), HAML (including embedded Ruby and comments), JSON, Markdown inline directives, Pug (handling class shorthands and attributes), Razor (including \@\ escaping), Ruby (percent literals, heredocs, and interpolation), Rust (Maud templates and Leptos \class:\ syntax), and Slim (including embedded Ruby \%w\ arrays). These changes improve extraction accuracy across these ecosystems by normalizing syntax-specific characters (like dots, brackets, and quotes) before candidate detection.

_crates/oxide/src/extractor/pre\processors · high confidence

The Node.js integration now exposes the underlying Oxide scanner, allowing users to programmatically scan content for Tailwind CSS candidates. This new API provides methods to scan files, scan raw content, and retrieve candidates along with their precise positions (converted to UTF-16 character indices for compatibility with editors). It also exposes metadata about the scanned files, globs, and normalized sources, enabling more granular control and debugging of the candidate extraction process within Node.js environments.

crates/node/src · high confidence

The new @tailwindcss-node package provides the Node.js-specific entry points and build configuration for Tailwind CSS. It includes a README with documentation and community links, a TypeScript configuration extending the base project settings, and a tsup build configuration that compiles the package into both CommonJS and ESM formats with minification and type definitions enabled for production use.

packages/@tailwindcss-node · high confidence

The @tailwindcss/postcss package is introduced, providing a PostCSS plugin for Tailwind CSS. It supports configuring the source file search directory via the \base\ option, allows enabling or disabling Lightning CSS optimization (including minification control) via the \optimize\ option, and handles \@import\ resolution with configurable \url()\ rewriting through the \transformAssetUrls\ option. The package is built to output both ESM and CommonJS formats.

packages/@tailwindcss-postcss · high confidence

This change introduces the initial structure for the \@tailwindcss-upgrade\ package, a new command-line interface designed to assist with upgrading Tailwind CSS projects. The package includes a help command that renders formatted usage instructions and options in the terminal, respecting terminal width for proper wrapping and alignment. It also sets up the build configuration using \tsup\ to output an ESM bundle and configures the TypeScript project with synthetic default import support.

packages/@tailwindcss-upgrade · high confidence

The \@tailwindcss-upgrade\ package now includes a new set of internal utilities to support the migration process. This adds a CLI argument parser (\args\) that handles type conversion and aliases, a static plugin extractor (\extract-static-plugins\) that uses Tree-sitter to parse Tailwind configuration files, and helpers for safe file writing (\write-file-safely\) and package manager detection (\packages\). It also introduces utilities for resolving module paths (\resolve\), checking Git repository status (\git\), formatting performance durations (\format-ns\), and rendering styled console output (\renderer\).

packages/@tailwindcss-upgrade/src/utils · high confidence

Adds a new browser-focused package that bundles Tailwind CSS into a self-contained IIFE, ensuring it does not pollute the global namespace. The package includes configuration for building via tsup (with specific loaders and plugin patches for IntelliSense APIs) and sets up Playwright for cross-browser testing (Chromium, Firefox, and WebKit on non-Windows platforms) alongside Vitest for unit tests.

packages/@tailwindcss-browser · high confidence

A new \@tailwindcss-browser\ package is introduced, enabling Tailwind CSS to be compiled directly in the browser. This package provides a runtime compiler that reads \\<style type="text/tailwindcss"\>\ tags, processes them using the core Tailwind engine, and injects the resulting CSS into the page. It supports standard Tailwind imports (preflight, theme, utilities) via virtual modules and includes instrumentation hooks for browser performance monitoring, while explicitly restricting support to browser environments by disabling plugin and config file loading.

packages/@tailwindcss-browser/src · high confidence

A new \@tailwindcss/turbopack\ package has been added, providing a dedicated loader for integrating Tailwind CSS v4 with Turbopack. This loader processes CSS files containing Tailwind directives (such as \@import 'tailwindcss'\), scanning for class candidates and compiling the final CSS output. It supports configuration options to specify a base directory for scanning and to control CSS optimization/minification, and includes caching and incremental rebuild strategies to maintain build performance.

packages/@tailwindcss-turbopack, packages/@tailwindcss-webpack · high confidence

Adds the new \@tailwindcss/vite\ package, providing a Vite plugin that scans source files for Tailwind classes, resolves CSS/JS imports using Vite's resolver API (supporting both legacy and Environment APIs), and processes CSS output with optional optimization and minification. The plugin handles source maps, supports SSR builds, and integrates with Vite's dependency graph to ensure efficient incremental builds.

packages/@tailwindcss-vite/src · high confidence

The \@tailwindcss/postcss\ package now includes a dedicated AST conversion layer (\ast.ts\) that translates between PostCSS AST nodes and Tailwind's internal CSS AST. This enables the PostCSS plugin to process Tailwind CSS features by converting the incoming PostCSS tree into the internal format for compilation, and then converting the result back to PostCSS for output. The change also adds comprehensive tests for this bidirectional conversion to ensure correctness.

packages/@tailwindcss-postcss/src · high confidence

The \@tailwindcss/node\ package now provides a dedicated Node.js environment for compiling Tailwind CSS, featuring robust module resolution for both JavaScript and TypeScript files (via Jiti fallback), automatic rewriting of relative CSS URLs, and support for source maps. It includes an instrumentation system for debug timing, a custom ESM cache loader to handle module reloading, and specific optimizations such as suppressing warnings for framework-specific pseudo-classes like \:deep\ and \:host-context()\.

packages/@tailwindcss-node/src · high confidence

This change introduces the foundational codebase for Tailwind CSS v4 within the \packages/tailwindcss\ directory. It establishes a new modular architecture by splitting the core CSS into distinct \theme.css\, \preflight.css\, and \utilities.css\ files, orchestrated via a new \index.css\ entry point. The package now includes a Playwright configuration for browser-based testing and a \tsup\ build configuration that exposes specific entry points for ESM and CJS formats, including new exports for \plugin\, \colors\, \default-theme\, and \flatten-color-palette\ utilities.

packages/tailwindcss · high confidence

The CLI is now distributed as a dedicated \@tailwindcss/cli\ package, featuring a new \build\ command that compiles CSS from an input file (or stdin) to an output file (or stdout). This command supports watch mode with optional polling, source map generation, output minification/optimization, and silent mode, while including validation to prevent identical input/output paths and handling of special file descriptors.

packages/@tailwindcss-cli/src/commands/build · high confidence

The \@tailwindcss-standalone\ package now provides a self-contained CLI that bundles the core Tailwind CSS APIs, allowing them to be imported and used directly within configuration files and plugins. This entry point registers a Bun plugin to bundle specific Tailwind modules (such as \tailwindcss\, \colors\, and \plugin\) and exposes global hooks (\\_\_tw\resolve\, \\\_tw\_load\) to handle resolution and loading of embedded CSS files and core plugins like \@tailwindcss/forms\ and \@tailwindcss/typography\ without external dependencies.

packages/@tailwindcss-standalone/src · high confidence

The CLI has been moved to its own package, and this change introduces the help command implementation for the new \@tailwindcss/cli\. The \help\ function now dynamically renders usage instructions and available options, automatically wrapping text to fit the terminal width and aligning option descriptions with dot-spacers for readability. This provides a consistent, formatted help output for users interacting with the CLI's commands and flags.

packages/@tailwindcss-cli/src/commands/help · high confidence

The Tailwind CSS CLI is now available as a dedicated \@tailwindcss/cli\ package. This entry point introduces two primary sub-commands: \build\, which compiles CSS from an input file, and \canonicalize\, which processes candidate lists. The CLI supports standard options like \--input\, \--output\, \--watch\, and \--poll\, and defaults to writing output to stdout if no output file is specified.

packages/@tailwindcss-cli/src · high confidence

The \@tailwindcss/upgrade\ tool now includes a comprehensive set of new codemods in the \css\ directory to automatically migrate CSS files from Tailwind CSS v3 to v4. These changes introduce specific PostCSS plugins that handle key migration tasks: \migrate-at-apply\ converts legacy \@apply\ rules to the new utility syntax, \migrate-at-layer-utilities\ transforms \@layer utilities\ blocks into individual \@utility\ at-rules, and \migrate-media-screen\ updates deprecated \@screen\ and \@media screen(...)\ syntax to the new \@media (width \>= ...)\ format. Additionally, \migrate-import\ ensures relative imports have the \.css\ extension, \migrate-missing-layers\ wraps orphaned rules in the correct \@layer\ directives, \migrate-config\ injects \@config\ and \@source\/\@plugin\ directives based on JS configuration, and \link\ resolves configuration paths for stylesheets. The \format-nodes\ plugin uses Prettier to clean up the output, while \analyze\ and \walk\ utilities support the new dependency graph and file traversal logic.

packages/@tailwindcss-upgrade/src/codemods/css · high confidence

The \classification-macros\ crate now provides the \ClassifyBytes\ derive macro, allowing enums to be automatically mapped from byte values (\u8\). By using attributes like \\#\[bytes(...)\]\ for specific characters, \\#\[bytes\_range(...)\]\ for ranges, and \\#\[fallback\]\ for a default case, the macro generates a static lookup table and \From\<u8\>\/\From\<&u8\>\ implementations. This enables efficient, compile-time classification of bytes into enum variants without runtime branching.

crates/classification-macros · high confidence

Added new playground environments for testing Tailwind CSS v4 with Next.js and Vite. The Next.js playgrounds (v3 and nextjs) provide starter projects configured with Tailwind CSS v4 via the new PostCSS plugin (\@tailwindcss/postcss\) and the App Router structure, including a script to facilitate upgrading from v3. The Vite playground demonstrates integration using the dedicated \@tailwindcss/vite\ plugin. These changes introduce new configuration files, TypeScript setups, and example components to help users experiment with the v4 codebase in popular frameworks.

playgrounds · high confidence

The \@tailwindcss/upgrade\ package is introduced to help users migrate their projects from Tailwind CSS v3 to v4. This CLI tool automatically migrates CSS stylesheets (converting \@tailwind\ directives to \@import 'tailwindcss'\ and handling layer imports), updates JavaScript configuration files to the new CSS-based format, and adjusts template files. It includes safeguards such as requiring a clean git state (unless \--force\ is used) and detecting version mismatches to ensure a smooth transition.

packages/@tailwindcss-upgrade/src · high confidence

The \@tailwindcss-postcss\ package now includes a PostCSS plugin that automatically rewrites relative paths in \@source\ and \@plugin\ directives to be relative to the initial CSS file being processed. This ensures that when stylesheets are imported from different locations, the internal references to source files and plugins remain valid and correctly resolved, preventing broken paths in nested or imported CSS structures.

packages/@tailwindcss-postcss/src/postcss-fix-relative-paths · high confidence

The standalone CLI build process has been updated to produce native binaries for Linux (x64 and ARM64, both glibc and musl), macOS (x64 and ARM64), and Windows (x64). These binaries are compiled using Bun's baseline targets to ensure compatibility with older hardware, and checksums are generated for verification. This change replaces previous methods of distributing the CLI, providing a more robust and performant experience across different operating systems and architectures.

packages/@tailwindcss-standalone/scripts · high confidence

This release marks the official launch of Tailwind CSS v4, introducing a new CSS-first configuration model, a rewritten engine (Oxide) for significantly faster builds, and a redesigned default theme. Users will experience faster development workflows with improved incremental rebuilds and a simplified setup process, alongside new utilities and features such as logical properties, arbitrary values, and enhanced variant support.

(repo-wide) · high confidence

The \@tailwindcss/vite\ plugin introduces an \optimize\ option that allows users to control Lightning CSS behavior. By default, Lightning CSS is enabled for production builds, but users can now explicitly disable it entirely or keep it enabled while disabling minification by passing \{ minify: false }\ to the \optimize\ option in the Vite configuration.

packages/@tailwindcss-vite · high confidence

The base styling layer and animation utilities have been removed from the codebase. This change deletes the \src/base\ directory, which previously imported normalize.css and suitcss-base, defined global typography and viewport settings, and managed color variables for the application's theme. Additionally, the \src/glitter\ directory's animation and transition mixins (including slide, fade, and stretch effects) have been deleted. Users will no longer have access to these default global styles and CSS transition classes.

src/base · high confidence

The \src/utilities\ directory has been cleaned up by deleting the legacy Less utility files for backgrounds, borders, flex, layout, links, misc, spacing, text, Vue-specific helpers, and z-index. These files, which previously provided hardcoded classes for styling, are no longer part of the codebase, indicating a shift toward a different styling approach or generator system.

src/utilities · high confidence

The \src/components\ directory has been cleared of its previous UI styling definitions. Specifically, the LESS files for alerts, buttons, cards, dropdowns, forms, grid layouts, horizontal rules, icons, images, lists, markdown, media objects, and progress bars have been deleted. This removes the visual presentation layer for these specific interface elements from this location.

src/components · high confidence

The \packages/tailwindcss/src\ directory now contains the complete source code for the Tailwind CSS v4 engine, introducing a new internal Abstract Syntax Tree (AST) for CSS processing. This change replaces the previous PostCSS-based pipeline with a custom parser and transformer that handles \@apply\, \@import\, and \@utility\ directives natively. The diff includes the core AST node definitions, candidate parsing logic, attribute selector parsing, and the \@apply\ substitution engine, marking a fundamental architectural shift in how Tailwind generates and optimizes CSS.

packages/tailwindcss/src · high confidence

The build process now automatically moves compiled Node.js native modules and WebAssembly artifacts into their respective npm sub-packages. This ensures that the new \wasm32-wasi\ target and its associated browser workers are correctly packaged and distributed alongside standard native bindings.

crates/node/scripts · high confidence

The upgrade tool now automatically converts JavaScript configuration files and PostCSS setups to the new Tailwind CSS v4 format. For JS configs, it migrates theme keys such as \aria\, \data\, and \supports\ into custom variants, handles \keyframes\ and \container\ definitions, and removes the deprecated \corePlugins\ option. For PostCSS setups, it replaces the \tailwindcss\ plugin with \@tailwindcss/postcss\, removes \autoprefixer\ and \postcss-import\ (if no other unknown plugins precede Tailwind), and installs the necessary \@tailwindcss/postcss\ package.

packages/@tailwindcss-upgrade/src/codemods/config · high confidence

The \packages/tailwindcss/src/compat\ directory introduces a comprehensive compatibility layer that allows Tailwind CSS v4 to process v3-style JavaScript configuration files and plugins. This includes mapping legacy theme keys (such as \fontFamily\ and \borderRadius\) to new CSS variable namespaces, resolving dot-notation theme paths, and supporting v3 plugin APIs like \addUtilities\ and \matchUtilities\. The layer also handles v3-specific features such as the \container\ component configuration, \darkMode\ strategies (media, selector, variant), and legacy utility classes like \bg-gradient-to-\\ and \max-w-screen-\\, ensuring that existing projects can migrate incrementally without breaking changes.

packages/tailwindcss/src/compat · high confidence

The application now handles specific platform constraints more robustly by patching three native dependencies. First, @napi-rs/cli is patched to retry WASI initialization with narrower preopens, preventing load failures on sandboxed environments like OpenHarmony. Second, @parcel/watcher and lightningcss are patched to support explicit libc selection via the PLATFORM\_LIBC environment variable (musl or glibc) and to enforce stricter libc detection on Linux, ensuring the correct native binary is loaded for the host system.

patches · high confidence

This release introduces a new, high-performance content scanning engine written in Rust, replacing the previous JavaScript-based implementation. The new \oxide\ crate provides a significantly faster mechanism for extracting utility class candidates from source files, directly improving build times for large projects. It includes optimized glob pattern handling to scope file system scans more efficiently and supports a wide range of template languages and preprocessors, including Vue, Next.js, Haml, JSON, Glimmer, and Razor (\.cshtml\).

crates/oxide/src · high confidence

The CLI tool is now distributed as a separate \@tailwindcss/cli\ package, isolated from the core library. This change includes the initial package structure with its own TypeScript configuration and build settings, establishing a dedicated entry point for command-line usage.

packages/@tailwindcss-cli · medium confidence

The Next.js playground has been updated to use the App Router structure, introducing new layout and page components that replace the previous pages directory approach. The styling system has shifted to Tailwind CSS v4, evidenced by the new globals.css importing the framework and the use of @reference and @apply directives in module styles, providing a modern, component-scoped styling experience for users experimenting with the framework.

playgrounds/nextjs · high confidence

The \@tailwindcss/cli\ package introduces a new internal argument parsing system (\args\) that supports type conversion (boolean, number, string), aliases, and defaults, with a specific behavioral change that duplicate CLI flags now use the last provided value. This location also adds utility modules for the CLI: \renderer\ for formatted console output (including ANSI-aware word wrapping and color-coded duration formatting), \format-ns\ for human-readable time durations, \disposables\ for resource cleanup, and \resolve\ for file path resolution using \enhanced-resolve\. Comprehensive test coverage is added for these new utilities.

packages/@tailwindcss-cli/src/utils · high confidence

The scanner has been rewritten in Rust (Oxide) to significantly improve build performance, especially in large projects and on Windows. This update introduces automatic source detection that intelligently scans project directories while ignoring common content folders (like .git, node\modules) and binary files. It supports explicit @source patterns, @source not exclusions, and external sources, ensuring that explicitly listed files are scanned even if they would normally be ignored. Debug logging is now written to a .tailwindcss/logs directory when DEBUG=\ is set, and the scanner handles symlinks and incremental builds more robustly.

crates/oxide/src/scanner · high confidence

The \packages/tailwindcss/src/utils\ directory now includes a suite of new internal utility modules to support the v4 codebase, including \brace-expansion\ for pattern expansion, \compare\ and \compare-breakpoints\ for natural sorting of classes and media queries, \decode-arbitrary-value\ for handling CSS values and math operators, \escape\ for CSS identifier serialization, \infer-data-type\ for validating CSS data types, and \replace-shadow-colors\ for managing shadow color variables. Comprehensive test coverage has been added for these utilities to ensure correct behavior.

packages/tailwindcss/src/utils · high confidence

The repository now includes a suite of new scripts in the \scripts/\ directory to streamline the release process. \version-packages.mjs\ manages version bumps across the monorepo, including synchronized updates for platform-specific \@tailwindcss/oxide\ packages. \lock-pre-release-versions.mjs\ normalizes pre-release dependencies to \workspace:\*\ to simplify publishing. \pack-packages.mjs\ handles the creation of distribution tarballs, optimizing for pnpm v10+ hoisted linkers where needed. \pre-publish-optimizations.mjs\ inlines CSS imports at build time to reduce runtime overhead. Additionally, \release-channel.js\ and \release-notes.mjs\ automate the determination of npm release channels and the extraction of changelog entries for GitHub releases.

scripts · high confidence

A new compatibility configuration system has been added to Tailwind CSS to bridge the gap between v3 and v4 theme structures. This system maps v3 theme keys (such as \fontSize\, \boxShadow\, \animation\, \aspectRatio\, \borderRadius\, \screens\, \letterSpacing\, \lineHeight\, and \maxWidth\) to their corresponding v4 CSS namespaces (like \--text\, \--shadow\, \--animate\, \--aspect\, \--radius\, \--breakpoint\, \--tracking\, \--leading\, and \--container\). It also introduces a safe namespace lookup mechanism that prevents errors when spreading theme values, ensuring that bare values resolve to objects with a \DEFAULT\ key rather than causing character-indexed garbage. Additionally, the system supports v3 configuration features including \darkMode\, \prefix\, \blocklist\, \important\, \future\, and \experimental\ keys, and provides a robust config resolution engine that handles deep merging, plugin presets, and theme key references.

packages/tailwindcss/src/compat/config · high confidence

The custom LESS styles for Stripe Elements, including focus states and stacked form group adjustments, have been removed from the codebase. This change eliminates the specific visual overrides previously applied to Stripe input fields, meaning these elements will now rely on default styling or styles defined elsewhere.

src/libraries · high confidence

The main application stylesheet (src/app.less) has been removed. This file previously served as the central entry point that aggregated base styles, component definitions (such as forms, buttons, and cards), utility classes, and animation effects. Its removal indicates a shift in how styles are managed or imported within the application.

src · high confidence

The class-name extraction engine in the \oxide\ crate has been completely rewritten to improve performance and robustness. The new implementation uses a state-machine architecture to correctly handle complex syntax, including arbitrary properties (e.g., \\[color:red\]\), arbitrary values (e.g., \bg-\[\#0088cc\]\), and arbitrary variables (e.g., \bg-red-500/(--my-opacity)\). It also adds support for extracting CSS variables from \.css\ files, handles template-specific syntaxes like Haml and Leptos \class:\ attributes, and correctly processes boundary characters in various languages such as Clojure, Ruby, and PHP.

crates/oxide/src/extractor · high confidence

The \@tailwindcss/upgrade\ tool now includes a comprehensive set of codemods for migrating HTML and JSX templates from Tailwind CSS v3 to v4. This update introduces the core candidate extraction logic using \@tailwindcss/oxide\ and a suite of migration steps: it handles legacy class renames (e.g., \shadow\ to \shadow-sm\, \blur\ to \blur-sm\), modernizes arbitrary values (e.g., converting \group-\[\]\ to \in-\[.group\]\), migrates camelCase named values to kebab-case, and ensures safe migration by skipping classes in invalid contexts like inline styles, JavaScript variables, or Vue/Alpine conditional bindings. It also supports migrating custom prefixes and handling empty arbitrary values.

packages/@tailwindcss-upgrade/src/codemods/template · high confidence

The \ignore\ crate has been updated from version 0.4.24 to 0.4.33. This update includes support for the \@source not\ syntax in gitignore files, allowing users to explicitly mark the source of ignore rules. It also introduces incremental path matching capabilities via the new \IncrementalIgnore\ API, which enables efficient checking of individual paths against hierarchical ignore files without full directory traversal. Additionally, the crate now supports ignoring binary extensions except when they appear in folder names, improving file type filtering accuracy. Several bug fixes and performance improvements are included in this release.

crates/ignore · high confidence

Added UI tests for gradient and mask utilities; Added UI tests for the @tailwindcss/browser package; Added comprehensive scanner tests with visual tree output; Added integration test for @tailwindcss/turbopack loader; Added integration tests for the PostCSS plugin; Added integration tests for the Tailwind CSS v3 to v4 upgrade tool; Added snapshot tests for CSS compilation, IntelliSense, and utilities; Added snapshot tests for PostCSS integration output; Added tests for WASM fallback and worker thread support; Added tests for the @tailwindcss/webpack loader and PostCSS watch integration; Expanded integration test coverage for the Vite plugin; Improved HAML extraction with embedded Ruby and comments; Integration tests for the Tailwind CSS CLI; New integration test infrastructure for Vite and Next.js.

The project now includes a new Rust-based scanning engine (Oxide) to improve performance, distributed as native binaries for multiple platforms (Linux, macOS, Windows, FreeBSD, Android, and WASI) via the \@tailwindcss/oxide\ npm package. This change introduces a new Rust workspace with crates for the core engine, Node.js bindings, and platform-specific builds, along with the necessary Cargo lockfiles and npm package configurations to support these native dependencies.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 55 (+17.7)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 80 → 67 (-12.7)
• Architecture 57 (new)
• Maturity 45 → 49 (+4.8)
• Readiness 20 → 57 (+37.4)
• Security 56 → 69 (+12.7)

• Boundary-crossing change coupling: compile.ts ↔ at-import.ts (packages/@tailwindcss-node/src/compile.ts)
• Boundary-crossing change coupling: index.ts ↔ index.ts (packages/@tailwindcss-node/src/index.ts)
• Boundary-crossing change coupling: index.ts ↔ index.ts (packages/@tailwindcss-node/src/index.ts)
• Boundary-crossing change coupling: index.ts ↔ index.ts (packages/@tailwindcss-node/src/index.ts)
• Boundary-crossing change coupling: index.ts ↔ run.ts (packages/@tailwindcss-postcss/src/index.ts)
• Boundary-crossing change coupling: index.ts ↔ run.ts (packages/@tailwindcss-vite/src/index.ts)
• Change coupling: at-import.ts ↔ index.ts (packages/tailwindcss/src/at-import.ts)
• Change coupling: compile.ts ↔ index.ts (packages/@tailwindcss-node/src/compile.ts)
• Dimension evaluation failed
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• High CVE: [GHSA redacted] (pnpm-lock.yaml)
• Hotspot: integrations/utils.ts (integrations/utils.ts)
• …and 25 more

• Ambiguous 'len' vs 'num_*' semantics. len() returns a usize (likely total entries or lines), while num_ignores and num_whitelists return u64 (specific counts). It is unclear if len() is the sum of the two, or something else (e.g., raw line count including comments). This forces users to guess whether len() is the aggregate they need or if they must sum the specific counters.
• ArbitraryPropertyMachine::next (cyclomatic 16) (crates/oxide/src/extractor/arbitrary_property_machine.rs)
• ArbitraryValueMachine::next (cognitive 17) (crates/oxide/src/extractor/arbitrary_value_machine.rs)
• CandidateMachine::next (cognitive 48) (crates/oxide/src/extractor/candidate_machine.rs)
• CandidateMachine::next (cyclomatic 20) (crates/oxide/src/extractor/candidate_machine.rs)
• Change coupling: index.ts ↔ run.ts (packages/@tailwindcss-vite/src/index.ts)
• Clojure::process (cognitive 45) (crates/oxide/src/extractor/pre_processors/clojure.rs)
• Clojure::process (cyclomatic 27) (crates/oxide/src/extractor/pre_processors/clojure.rs)
• Coverage not measured — JavaScript/TypeScript suite
• Critical vulnerability: [GHSA redacted] (pnpm-lock.yaml)
• CssVariableMachine::next (cognitive 16) (crates/oxide/src/extractor/css_variable_machine.rs)
• Documentation: no project overview (crates/node/npm/wasm32-wasi/README.md)
• Duplicated block (11 lines × 2) (crates/ignore/src/dir.rs)
• Duplicated block (11 lines × 2) (crates/oxide/src/extractor/named_utility_machine.rs)
• Duplicated block (15 lines × 2) (crates/oxide/src/scanner/sources.rs)
• Duplicated block (16 lines × 2) (crates/oxide/src/extractor/pre_processors/pre_processor.rs)
• Duplicated block (17 lines × 2) (crates/oxide/src/extractor/pre_processors/json.rs)
• Duplicated block (18 lines × 3) (crates/oxide/src/extractor/arbitrary_property_machine.rs)
• Duplicated block (20 lines × 3) (crates/oxide/src/extractor/pre_processors/clojure.rs)
• Duplicated block (22 lines × 2) (crates/oxide/src/extractor/arbitrary_property_machine.rs)
• …and 378 more

• 19 commits — 16 feature/other, 3 fixes

• packages/tailwindcss — 10 commits
• crates/oxide — 4 commits
• (root) — 2 commits
• crates/ignore — 1 commit
• integrations/vite — 1 commit
• packages/@tailwindcss-cli — 1 commit

• fix: Fix slow Vite rebuilds in projects with large gitignored directories (#20408)
• fix: fix referenced link
• fix: fix: Drop invalid UTF-8 scanner candidates (#20389)
• change: Canonicalization: prevent inlining CSS-wide keywords (#20417)
• change: Cold start performance improvements (#20427)
• change: Do not force full page reloads when using @tailwindcss/vite (#20414)
• change: Don't emit utilities that resolve a theme value when an unsupported modifier is used (#20419)
• change: Don't space out and/or/not inside function calls in supports-[…] variants (#20420)
• change: Don't treat \ as an escape inside CSS comments (#20508)
• change: Don't warn about Angular's ::ng-deep and :host-context() when optimizing CSS (#20434)
• change: Improve style invalidation performance of group-* and peer-* variants (#20513)
• change: Make createCompatConfig theme mappings safe to spread when a namespace returns a string (#20399)
• change: Move debug logs in .tailwindcss folder (#20416)
• change: Reject candidates with multiple modifiers (#20466)
• change: Sort breakpoint variants with decimal values numerically (#20512)
• change: Visualize scanner related tests (#20412)
• change: fix: correct two comment typos (#20507)
• change: rebase ignore crate from 0.4.24 to 0.4.33 (#20409)
• change: test: fix 'with with' typo in css parser tests (#20410)

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

tailwindlabs/tailwindcss was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.