Tool for transforming styles with JS plugins


PostCSS is a tool for transforming styles with JS plugins. These plugins can lint your CSS, support variables and mixins, transpile future CSS syntax, inline images, and more.

PostCSS is used by industry leaders including Google, Twitter, Alibaba, and Shopify. The Autoprefixer PostCSS plugin is one of the most popular CSS processors.

Twitter account: @postcss. page: postcss. Support / Discussion: Gitter.

Currently, PostCSS has more than 200 plugins. Here are our favorite plugins which best demonstrate PostCSS’ power. You can find all of the plugins in the plugins list or in the searchable catalog.

If you have any new ideas, PostCSS plugin development is really easy.

  • autoprefixer adds vendor prefixes, using data from Can I Use.
  • cssnext allows you to use future CSS features today (includes autoprefixer).
  • precss contains plugins for Sass-like features like nesting or mixins.
  • postcss-sorting sorts rules content with specified order.
  • short adds and extends numerous shorthand properties.
  • stylelint is a modular linter for CSS.
  • doiuse lints CSS for browser support, using data from Can I Use.
  • colorguard helps maintain a consistent color palette.
  • lost is feature-rich calc() grid system by Jeet author.
  • cssnano is a modular CSS minifier.
  • rtlcss mirrors styles for right-to-left locales.

PostCSS can transform styles in any syntax, not just CSS.

  • postcss-scss to work with SCSS (but does not compile SCSS to CSS).
  • postcss-js to write styles in JS or transform React Inline Styles, Radium or JSS.
  • postcss-safe-parser finds and fixes CSS syntax errors.
  • midas converts a CSS string to highlighted HTML.

You can start using PostCSS in just two steps:

  1. Find and add PostCSS extensions for your build tool.
  2. Select plugins and add them to your PostCSS process.

Use gulp-postcss and gulp-sourcemaps.

gulp.task('css', function () {
    var postcss    = require('gulp-postcss');
    var sourcemaps = require('gulp-sourcemaps');
    return gulp.src('src/**/*.css')
        .pipe( sourcemaps.init() )
        .pipe( postcss([ require('autoprefixer'), require('precss') ]) )
        .pipe( sourcemaps.write('.') )
        .pipe( gulp.dest('build/') );

Use postcss-loader:

module.exports = {
    module: {
        loaders: [
                test:   /\.css$/,
                loader: "style-loader!css-loader!postcss-loader"
    postcssfunction () {
        return [require('autoprefixer'), require('precss')];

To use PostCSS from your command-line interface or with npm scripts there is: postcss-cli.

postcss --use autoprefixer -c options.json -o main.css css/*.css

For React Inline Styles, JSS, Radium and other CSS-in-JS you can use postcss-js to transform one style object to other.

var postcss  = require('postcss-js');
var prefixer = postcss.sync([ require('autoprefixer') ]);
prefixer({ display: 'flex' }); //=> { display: ['-webkit-box', '-webkit-flex', '-ms-flexbox', 'flex'] } 

For other environments, you can use the JS API:

var postcss = require('postcss');
postcss([ require('autoprefixer'), require('cssnano') ])
    .process(css, { from: 'src/app.css', to: 'app.css' })
    .then(function (result) {
        fs.writeFileSync('app.css', result.css);
        if ( ) fs.writeFileSync('',;

Read the PostCSS API documentation for more details about the JS API.

All PostCSS JS API users should pass PostCSS Runner Guidelines.

Most PostCSS runners accept two parameters:

  • An array of plugins.
  • An object of options.

Common options:

  • syntax: object with syntax parser and stringifier.
  • parser: other syntax parser (for example, SCSS).
  • stringifier: other syntax output generator (for example, Midas).
  • map: source map options.
  • from: input file name (most runners set it automatically).
  • to: output file name (most runners set it automatically).

If you want to run PostCSS on node.js 0.10, add the Promise polyfill:

var postcss = require('postcss');