Functions & Directives

A reference for the custom functions and directives Tailwind exposes to your CSS.

@tailwind

Use the @tailwind directive to insert Tailwind’s base, components, utilities and screens styles into your CSS.

  1. /**
  2.  * This injects Tailwind's base styles and any base styles registered by
  3.  * plugins.
  4.  */
  5. @tailwind base;
  7. /**
  8.  * This injects Tailwind's component classes and any component classes
  9.  * registered by plugins.
  10.  */
  11. @tailwind components;
  13. /**
  14.  * This injects Tailwind's utility classes and any utility classes registered
  15.  * by plugins.
  16.  */
  17. @tailwind utilities;
  19. /**
  20.  * Use this directive to control where Tailwind injects the responsive
  21.  * variations of each utility.
  22.  *
  23.  * If omitted, Tailwind will append these classes to the very end of
  24.  * your stylesheet by default.
  25.  */
  26.  @tailwind screens;

@apply

Use @apply to inline any existing utility classes into your own custom CSS.

This is useful when you find a common utility pattern in your HTML that you’d like to extract to a new component.

  1. .btn {
  2.   @apply font-bold py-2 px-4 rounded;
  3. }
  4. .btn-blue {
  5.   @apply bg-blue-500 text-white;
  6. }
  7. .btn-blue:hover {
  8.   @apply bg-blue-700;
  9. }

Rules can be listed on a single line or with multiple calls to @apply:

  1. .btn {
  2.   @apply font-bold;
  3.   @apply py-2;
  4.   @apply px-4;
  5.   @apply rounded;
  6. }

You can mix @apply declarations with normal CSS declarations too of course:

  1. .btn:hover {
  2.   @apply bg-blue-700;
  3.   transform: translateY(-1px);
  4. }

Any rules inlined with @apply will have !important removed by default to avoid specificity issues:

  1. /* Input */
  2. .foo {
  3.   color: blue !important;
  4. }
  6. .bar {
  7.   @apply foo;
  8. }
  10. /* Output */
  11. .foo {
  12.   color: blue !important;
  13. }
  15. .bar {
  16.   color: blue;
  17. }

If you’d like to @apply an existing class and make it !important, simply add !important to the end of the declaration:

  1. /* Input */
  2. .btn {
  3.   @apply font-bold py-2 px-4 rounded !important;
  4. }
  6. /* Output */
  7. .btn {
  8.   font-weight: 700 !important;
  9.   padding-top: .5rem !important;
  10.   padding-bottom: .5rem !important;
  11.   padding-right: 1rem !important;
  12.   padding-left: 1rem !important;
  13.   border-radius: .25rem !important;
  14. }

Note that @apply will not work for inlining pseudo-class or responsive variants of another utility. Instead, apply the plain version of that utility into the appropriate pseudo-selector or a new media query:

  1. /* Won't work: */
  2. .btn {
  3.   @apply block bg-red-500;
  4.   @apply hover:bg-blue-500;
  5.   @apply md:inline-block;
  6. }
  8. /* Do this instead: */
  9. .btn {
  10.   @apply block bg-red-500;
  11. }
  12. .btn:hover {
  13.   @apply bg-blue-500;
  14. }
  15. @screen md {
  16.   .btn {
  17.     @apply inline-block;
  18.   }
  19. }

If you’ve configured a prefix for your utilities, you can optionally omit the prefix when using @apply if you prefer a terser syntax:

  1. /* Both of these will work */
  2. .btn {
  3.   @apply tw-font-bold tw-py-2 tw-px-4 tw-rounded;
  4. }
  5. .btn {
  6.   @apply font-bold py-2 px-4 rounded;
  7. }

@variants

You can generate responsive, hover, focus, active, and group-hover versions of your own utilities by wrapping their definitions in the @variants directive

  1. @variants focus, hover {
  2.   .rotate-0 {
  3.     transform: rotate(0deg);
  4.   }
  5.   .rotate-90 {
  6.     transform: rotate(90deg);
  7.   }
  8. }

This will generate the following CSS:

  1. .rotate-0 {
  2.   transform: rotate(0deg);
  3. }
  4. .rotate-90 {
  5.   transform: rotate(90deg);
  6. }
  8. .focus\:rotate-0:focus {
  9.   transform: rotate(0deg);
  10. }
  11. .focus\:rotate-90:focus {
  12.   transform: rotate(90deg);
  13. }
  15. .hover\:rotate-0:hover {
  16.   transform: rotate(0deg);
  17. }
  18. .hover\:rotate-90:hover {
  19.   transform: rotate(90deg);
  20. }

It’s important to note that variants are generated in the order you specify them.

So if you want focus utilities to take priority over hover utilities for example, make sure focus comes after hover in the list:

  1. /* Input */
  2. @variants hover, focus {
  3.   .banana {
  4.     color: yellow;
  5.   }
  6. }
  8. /* Output */
  9. .banana {
  10.   color: yellow;
  11. }
  12. .hover\:banana:hover {
  13.   color: yellow;
  14. }
  15. .focus\:banana:focus {
  16.   color: yellow;
  17. }

The @variants at-rule supports all of the values that are supported in the variants section of your config file:

  • responsive
  • hover
  • focus
  • active
  • group-hover
  • focus-within…as well as any custom variants added through plugins.

@responsive

You can generate responsive variants of your own classes by wrapping their definitions in the @responsive directive:

  1. @responsive {
  2.   .bg-gradient-brand {
  3.     background-image: linear-gradient(blue, green);
  4.   }
  5. }

Using the default breakpoints, this would generate these classes:

  1. .bg-gradient-brand {
  2.   background-image: linear-gradient(blue, green);
  3. }
  5. /* ... */
  7. @media (min-width: 640px) {
  8.   .sm\:bg-gradient-brand {
  9.     background-image: linear-gradient(blue, green);
  10.   }
  11.   /* ... */
  12. }
  14. @media  (min-width: 768px) {
  15.   .md\:bg-gradient-brand {
  16.     background-image: linear-gradient(blue, green);
  17.   }
  18.   /* ... */
  19. }
  21. @media (min-width: 1024px) {
  22.   .lg\:bg-gradient-brand {
  23.     background-image: linear-gradient(blue, green);
  24.   }
  25.   /* ... */
  26. }
  28. @media (min-width: 1280px) {
  29.   .xl\:bg-gradient-brand {
  30.     background-image: linear-gradient(blue, green);
  31.   }
  32.   /* ... */
  33. }

The responsive variants will be added to Tailwind’s existing media queries at the end of your stylesheet. This makes sure that classes with a responsive prefix always defeat non-responsive classes that are targeting the same CSS property.

@screen

The @screen directive allows you to create media queries that reference your breakpoints by name instead of duplicating their values in your own CSS.

For example, say you have a sm breakpoint at 640px and you need to write some custom CSS that references this breakpoint.

Instead of writing a raw media query that duplicates that value like this:

  1. @media (min-width: 640px) {
  2.   /* ... */
  3. }

…you can use the @screen directive and reference the breakpoint by name:

  1. @screen sm {
  2.   /* ... */
  3. }

theme()

Use the theme() function to access your Tailwind config values using dot notation.

This can be a useful alternative to @apply when you want to reference a value from your theme configuration for only part of a declaration:

  1. .content-area {
  2.   height: calc(100vh - theme('spacing.12'));
  3. }

Since Tailwind uses the nested object syntax to define its default color palette, make sure to use dot notation to access the nested colors.

Functions & Directives - 图1Don’t use the dash syntax when accessing nested color values

  1. .btn-blue {
  2.   background-color: theme('colors.blue-500');
  3. }

Functions & Directives - 图2Use dot notation to access nested color values

  1. .btn-blue {
  2.   background-color: theme('colors.blue.500');
  3. }