0Pricing
Tailwind CSS Academy · Lesson

Adding Custom Utilities via Plugin

Write a plugin that adds new utility classes like text-shadow-* or scrollbar-hide not present in the default Tailwind distribution.

Adding Custom Utilities via Plugin is a free Tailwind CSS Academy lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Tailwind CSS Academy learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

When to Add a Custom Utility

Add a custom utility when you find yourself repeatedly writing the same raw CSS in @apply blocks or inline styles, when Tailwind lacks a utility for a valid CSS property, or when a browser-specific prefix combination needs a clean class name. Good custom utilities follow Tailwind's single-responsibility principle: one utility controls one CSS property or a tightly related group. Avoid creating utilities that set many unrelated properties — those belong in components.

Scrollbar Hide Utility

One of the most commonly requested custom utilities is .scrollbar-hide — it hides the scrollbar visually while keeping the element scrollable. This requires vendor-specific properties across browsers: scrollbar-width: none for Firefox and -webkit-scrollbar: display none for Chromium browsers. Packaging this in a plugin makes it available as a simple scrollbar-hide class anywhere in your markup.

const plugin = require('tailwindcss/plugin');

module.exports = {
  plugins: [
    plugin(function({ addUtilities }) {
      addUtilities({
        '.scrollbar-hide': {
          '-ms-overflow-style': 'none',
          'scrollbar-width': 'none',
          '&::-webkit-scrollbar': {
            display: 'none'
          }
        },
        '.scrollbar-default': {
          '-ms-overflow-style': 'auto',
          'scrollbar-width': 'auto',
          '&::-webkit-scrollbar': {
            display: 'block'
          }
        }
      });
    })
  ]
};

// Usage
// <div class='overflow-x-auto scrollbar-hide'>...

Text Shadow Utilities

CSS text-shadow is a commonly used property that Tailwind does not include by default. Building a plugin for it with theme integration lets consumers use it like any built-in utility and also supports customization via the config. Define default values in the theme and reference them in the plugin so the utility respects user overrides in tailwind.config.js.

const plugin = require('tailwindcss/plugin');

module.exports = {
  theme: {
    extend: {
      textShadow: {
        sm: '0 1px 2px var(--tw-shadow-color, rgba(0,0,0,0.2))',
        DEFAULT: '0 2px 4px var(--tw-shadow-color, rgba(0,0,0,0.3))',
        lg: '0 4px 8px var(--tw-shadow-color, rgba(0,0,0,0.4))'
      }
    }
  },
  plugins: [
    plugin(function({ matchUtilities, theme }) {
      matchUtilities(
        { 'text-shadow': (value) => ({ textShadow: value }) },
        { values: theme('textShadow') }
      );
    })
  ]
};
// Usage: text-shadow-sm, text-shadow, text-shadow-lg
// Or arbitrary: text-shadow-[0_4px_6px_rgba(0,0,0,0.5)]

Writing Direction Utilities

CSS logical properties for writing direction (margin-inline-start, padding-inline-end, inset-inline-start) enable right-to-left (RTL) layout support without duplicate CSS. Tailwind v3 added some logical properties, but you can write a plugin to fill any remaining gaps with a consistent naming convention matching Tailwind's style.

plugin(function({ addUtilities, theme }) {
  const spacing = theme('spacing');
  const utilities = {};

  Object.entries(spacing).forEach(([key, value]) => {
    // Logical margin utilities (RTL-aware)
    utilities['.ms-' + key] = { 'margin-inline-start': value };
    utilities['.me-' + key] = { 'margin-inline-end': value };
    utilities['.ps-' + key] = { 'padding-inline-start': value };
    utilities['.pe-' + key] = { 'padding-inline-end': value };
    // Logical inset
    utilities['.start-' + key] = { 'inset-inline-start': value };
    utilities['.end-' + key] = { 'inset-inline-end': value };
  });

  addUtilities(utilities);
})

Gradient Text Utility

Gradient text requires a combination of three CSS properties: background-clip: text, -webkit-background-clip: text, and color: transparent. Since the actual gradient colors come from bg-gradient-to-* and from-*/to-* utilities, the plugin only needs to provide the clipping foundation. This is a classic multi-property utility that benefits from being a single, memorable class name.

plugin(function({ addUtilities }) {
  addUtilities({
    '.text-gradient': {
      '-webkit-background-clip': 'text',
      'background-clip': 'text',
      '-webkit-text-fill-color': 'transparent',
      'color': 'transparent'
    }
  });
})

// Usage: combine with standard bg-gradient utilities
<h1 class='
  text-gradient
  bg-gradient-to-r
  from-purple-500
  to-blue-500
  text-4xl font-bold
'>
  Beautiful gradient text
</h1>

Grid Auto-Fill Utility

CSS Grid's auto-fill and auto-fit repeat patterns for responsive grids are common but require verbose syntax. A plugin that generates parameterizable grid utilities for the most common column minimum widths makes responsive grids dramatically simpler to write. Use matchUtilities so users can specify arbitrary minimum column widths.

plugin(function({ matchUtilities }) {
  matchUtilities(
    {
      'grid-fill': (value) => ({
        gridTemplateColumns: 'repeat(auto-fill, minmax(' + value + ', 1fr))'
      }),
      'grid-fit': (value) => ({
        gridTemplateColumns: 'repeat(auto-fit, minmax(' + value + ', 1fr))'
      })
    },
    { values: { sm: '10rem', md: '15rem', lg: '20rem', xl: '25rem' } }
  );
})

// Usage:
// <div class='grid grid-fill-md gap-4'>
//   Items auto-arrange into columns of min 15rem
// </div>

CSS Grid Area Utilities

Named grid areas via grid-template-areas require verbose CSS that is hard to express in Tailwind's utility model. A plugin can add utilities for common named-area layouts — like a classic page layout with header, sidebar, main, and footer areas — as single utility classes. These pair well with col-span-* and row-span-* for more complex layouts.

plugin(function({ addUtilities }) {
  addUtilities({
    '.grid-area-page': {
      gridTemplateAreas:
        '"header header"' +
        '"sidebar main"' +
        '"footer footer"',
      gridTemplateColumns: '250px 1fr',
      gridTemplateRows: 'auto 1fr auto'
    },
    '.area-header': { gridArea: 'header' },
    '.area-sidebar': { gridArea: 'sidebar' },
    '.area-main': { gridArea: 'main' },
    '.area-footer': { gridArea: 'footer' }
  });
})

// Usage:
// <div class='grid grid-area-page min-h-screen'>
//   <header class='area-header'>...</header>
//   <aside class='area-sidebar'>...</aside>
//   <main class='area-main'>...</main>
//   <footer class='area-footer'>...</footer>
// </div>

Animation Utilities Beyond Built-Ins

Tailwind provides animate-spin, animate-pulse, animate-bounce, and animate-ping. For richer animations — like a wiggle, a heartbeat, or a float effect — add custom keyframes to the theme and reference them in a plugin. The plugin ensures the animation class names follow Tailwind's animate-* convention, keeping the system coherent.

// tailwind.config.js
module.exports = {
  theme: {
    extend: {
      keyframes: {
        wiggle: {
          '0%, 100%': { transform: 'rotate(-3deg)' },
          '50%': { transform: 'rotate(3deg)' }
        },
        heartbeat: {
          '0%, 100%': { transform: 'scale(1)' },
          '14%': { transform: 'scale(1.3)' },
          '28%': { transform: 'scale(1)' },
          '42%': { transform: 'scale(1.3)' },
          '70%': { transform: 'scale(1)' }
        }
      },
      animation: {
        wiggle: 'wiggle 1s ease-in-out infinite',
        heartbeat: 'heartbeat 1.5s ease-in-out infinite'
      }
    }
  }
};

// Usage: class='animate-wiggle' or class='animate-heartbeat'

Testing Your Custom Utilities

Verify your plugin utilities appear in the generated CSS by creating a test HTML file that uses the class names and running the Tailwind CLI. The JIT engine must find the class in a file matching your content globs. Also test that responsive and state variants work if you intend for them to — some pseudo-element utilities like ::-webkit-scrollbar do not support responsive prefixes meaningfully.

<!-- test.html -->
<div class='scrollbar-hide overflow-y-auto h-48'>
  <p class='text-shadow-lg text-2xl font-bold text-gray-900'>Test</p>
  <div class='grid grid-fill-md gap-4'>
    <div class='bg-gray-100 p-4 rounded'>Card 1</div>
    <div class='bg-gray-100 p-4 rounded'>Card 2</div>
  </div>
</div>

<!-- Run: npx tailwindcss -i src/input.css -o test-output.css --content test.html -->
<!-- Inspect test-output.css for your custom utility classes -->

Documenting Custom Utilities

Document custom utilities for your team so they know what exists and how to use it. Create a PLUGINS.md file or a Storybook page listing each custom utility with its class names, accepted values, and usage examples. Without documentation, team members often write the same CSS twice — once as a utility and again as inline styles — because they did not know the plugin existed.

/*
  Custom Utilities Documentation
  ================================

  .scrollbar-hide
    Hides the scrollbar while preserving scroll functionality.
    Use with: overflow-y-auto, overflow-x-auto
    Example: <div class='overflow-y-auto h-64 scrollbar-hide'>

  .text-shadow-{size}
    Adds a text shadow. Sizes: sm, DEFAULT, lg.
    Example: <h1 class='text-shadow-lg text-3xl font-bold'>
    Arbitrary: <h1 class='text-shadow-[0_4px_8px_rgba(0,0,0,0.5)]'>

  .text-gradient
    Enables gradient text via background-clip: text.
    Must combine with bg-gradient-to-* and from-*/to-* utilities.
    Example: <span class='text-gradient bg-gradient-to-r from-purple-500 to-pink-500'>

  .grid-fill-{size}
    Auto-fill grid with minimum column width. Sizes: sm, md, lg, xl.
    Example: <div class='grid grid-fill-md gap-4'>
*/

Performance Impact of Custom Utilities

Custom utilities add to your generated CSS size. If a utility generates many permutations (like spacing utilities across 30+ scale steps), the output can grow significantly. Be selective about which utilities you generate programmatically. Use matchUtilities with a small set of theme values and rely on arbitrary values for one-off cases, rather than pre-generating every possible combination. This keeps your CSS bundle lean while maintaining flexibility.

// Avoid: generates 30+ utilities upfront
plugin(function({ addUtilities, theme }) {
  const spacing = theme('spacing'); // 30+ entries
  const utils = {};
  Object.entries(spacing).forEach(([k, v]) => {
    utils['.clip-' + k] = { clipPath: 'inset(' + v + ')' };
  });
  addUtilities(utils); // large CSS output
});

// Better: use matchUtilities with limited defaults
plugin(function({ matchUtilities, theme }) {
  matchUtilities(
    { 'clip': (v) => ({ clipPath: 'inset(' + v + ')' }) },
    { values: { none: '0', sm: '0.5rem', md: '1rem' } }
    // Users can still do clip-[2rem] for custom values
  );
});

Quick Check

Test your understanding of Tailwind CSS Mastery concepts from this lesson.

Lesson Recap

In this lesson you learned: addUtilities adds static custom utility classes, matchUtilities adds utilities with arbitrary value support, and custom utilities should be documented and scoped to real, repeated needs. Next up we learn how to add custom state variants via plugins to target custom selectors and data attributes.

Frequently asked questions

Is the “Adding Custom Utilities via Plugin” lesson free?

Yes — the full text of “Adding Custom Utilities via Plugin” is free to read here on the web, and the Tailwind CSS Academy course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Tailwind CSS Academy course, upgrade to CoddyKit PRO.

What will I learn in “Adding Custom Utilities via Plugin”?

Write a plugin that adds new utility classes like text-shadow-* or scrollbar-hide not present in the default Tailwind distribution. You practise Tailwind CSS Academy with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Tailwind CSS Academy?

No prior experience is required. Tailwind CSS Academy on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Adding Custom Utilities via Plugin” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Tailwind CSS Academy lesson?

Yes. Every Tailwind CSS Academy lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

  1. The Tailwind Plugin API
  2. Adding Custom Utilities via Plugin
  3. Adding Custom Variants via Plugin
  4. Publishing and Reusing Plugins
← Back to Tailwind CSS Academy