autoprefixer

What is autoprefixer?

The autoprefixer npm package is a PostCSS plugin that parses your CSS and adds vendor prefixes to CSS rules using values from Can I Use. It is a tool that automates the process of adding vendor prefixes to CSS rules to ensure cross-browser compatibility.

What are autoprefixer's main functionalities?

Adding vendor prefixes

This feature automatically adds necessary vendor prefixes to CSS rules. The code sample shows how to use autoprefixer with PostCSS to process a CSS string that includes the 'display: flex;' rule, which then outputs the rule with the appropriate vendor prefixes.

const autoprefixer = require('autoprefixer');
const postcss = require('postcss');

postcss([ autoprefixer ]).process('a { display: flex; }').then(result => {
  console.log(result.css);
  // Output: 'a { display: -webkit-box; display: -ms-flexbox; display: flex; }'
});

Customizing browser support

Autoprefixer allows customization of the browsers you want to target. The code sample demonstrates how to specify the browsers using the 'overrideBrowserslist' option to target the last 2 versions of all browsers.

const autoprefixer = require('autoprefixer');
const postcss = require('postcss');

postcss([ autoprefixer({ overrideBrowserslist: ['last 2 versions'] }) ])
.process('a { display: flex; }').then(result => {
  console.log(result.css);
  // Output will include prefixes for the last 2 versions of all browsers.
});

Removing unnecessary prefixes

Autoprefixer can also remove outdated prefixes if they are no longer needed for the specified browser range. The code sample shows how to disable this feature using the 'remove' option.

const autoprefixer = require('autoprefixer');
const postcss = require('postcss');

postcss([ autoprefixer({ remove: false }) ])
.process('a { -webkit-box-shadow: 0 0 10px black; box-shadow: 0 0 10px black; }').then(result => {
  console.log(result.css);
  // Output will keep the -webkit-box-shadow prefix even if it's not necessary for the specified browsers.
});

Other packages similar to autoprefixer

postcss-preset-env

postcss-preset-env is a plugin that allows you to use future CSS features today. It includes autoprefixer functionality and extends it by allowing you to use future CSS syntax that is not yet fully supported in browsers.

cssnano

cssnano is a modular CSS minifier that includes autoprefixing as one of its optimizations. While autoprefixer focuses solely on adding prefixes, cssnano aims to reduce the size of CSS files by performing a variety of optimizations, including autoprefixing.

pleeease

pleeease is a CSS processor that combines several tools, including autoprefixer, to streamline the process of writing CSS. It simplifies the workflow by integrating autoprefixing, minification, and other features into one package.

README

Autoprefixer

PostCSS plugin to parse CSS and add vendor prefixes to CSS rules using values from Can I Use. It is recommended by Google and used in Twitter and Taobao.

Write your CSS rules without vendor prefixes (in fact, forget about them entirely):

:fullscreen a {
    display: flex
}

Autoprefixer will use the data based on current browser popularity and property support to apply prefixes for you. You can try the interactive demo of Autoprefixer.

:-webkit-full-screen a {
    display: -webkit-box;
    display: flex
}
:-moz-full-screen a {
    display: flex
}
:-ms-fullscreen a {
    display: -ms-flexbox;
    display: flex
}
:fullscreen a {
    display: -webkit-box;
    display: -ms-flexbox;
    display: flex
}

Twitter account for news and releases: @autoprefixer.

Features

Write Pure CSS

Working with Autoprefixer is simple: just forget about vendor prefixes and write normal CSS according to the latest W3C specs. You don’t need a special language (like Sass) or remember where you must use mixins.

Autoprefixer supports selectors (like :fullscreen and ::selection), unit function (calc()), at‑rules (@supports and @keyframes) and properties.

Because Autoprefixer is a postprocessor for CSS, you can also use it with preprocessors such as Sass, Stylus or LESS.

Flexbox, Filters, etc.

Just write normal CSS according to the latest W3C specs and Autoprefixer will produce the code for old browsers.

a {
    display: flex;
}

compiles to:

a {
    display: -webkit-box;
    display: -webkit-flex;
    display: -ms-flexbox;
    display: flex
}

Autoprefixer has 27 special hacks to fix web browser differences.

Only Actual Prefixes

Autoprefixer utilizes the most recent data from Can I Use to add only necessary vendor prefixes.

It also removes old, unnecessary prefixes from your CSS (like border-radius prefixes, produced by many CSS libraries).

a {
    -webkit-border-radius: 5px;
            border-radius: 5px;
}

compiles to:

a {
    border-radius: 5px;
}

Browsers

Autoprefixer uses Browserslist, so you can specify the browsers you want to target in your project by queries like last 2 versions or > 5%.

The best way to provide browsers is browserslist config or package.json with browserslist key. Put it in your project root.

We recommend to avoid Autoprefixer option and use browserslist config or package.json. In this case browsers will be shared with other tools like babel-preset-env or Stylelint.

See Browserslist docs for queries, browser names, config format, and default value.

Outdated Prefixes

By default, Autoprefixer also removes outdated prefixes.

You can disable this behavior with the remove: false option. If you have no legacy code, this option will make Autoprefixer about 10% faster.

Also, you can set the add: false option. Autoprefixer will only clean outdated prefixes, but will not add any new prefixes.

Autoprefixer adds new prefixes between any unprefixed properties and already written prefixes in your CSS. If it will break the expected prefixes order, you can clean all prefixes from your CSS and then add the necessary prefixes again:

var cleaner  = postcss([ autoprefixer({ add: false, browsers: [] }) ]);
var prefixer = postcss([ autoprefixer ]);

cleaner.process(css).then(function (cleaned) {
    return prefixer.process(cleaned.css)
}).then(function (result) {
    console.log(result.css);
});

FAQ

No prefixes in production

Many other tools contain Autoprefixer. For example, webpack uses Autoprefixer to minify CSS by cleaning unnecessary prefixes.

If you set browsers list to Autoprefixer by browsers option, only first Autoprefixer will know your browsers. Autoprefixer inside webpack will use default browsers list. As result, webpack will remove prefixes, that first Autoprefixer added.

You need to put your browsers to browserslist config in project root — as result all tools (Autoprefixer, cssnano, doiuse, cssnext) will use same browsers list.

Does it add polyfills?

No. Autoprefixer only adds prefixes.

Most new CSS features will require client side JavaScript to handle a new behavior correctly.

Depending on what you consider to be a “polyfill”, you can take a look at some other tools and libraries. If you are just looking for syntax sugar, you might take a look at:

• Oldie, a PostCSS plugin that handles some IE hacks (opacity, rgba, etc).
• postcss-flexbugs-fixes, a PostCSS plugin to fix flexbox issues.
• cssnext, a tool that allows you to write standard CSS syntax non-implemented yet in browsers (custom properties, custom media, color functions, etc).

Why doesn’t Autoprefixer add prefixes to border-radius?

Developers are often surprised by how few prefixes are required today. If Autoprefixer doesn’t add prefixes to your CSS, check if they’re still required on Can I Use.

There is a list with all supported properties, values, and selectors.

Why Autoprefixer uses unprefixed properties in @-webkit-keyframes?

Browser teams can remove some prefixes before others. So we try to use all combinations of prefixed/unprefixed values.

How to work with legacy -webkit- only code?

Autoprefixer needs unprefixed property to add prefixes. So if you only wrote -webkit-gradient without W3C’s gradient, Autoprefixer will not add other prefixes.

But PostCSS has a plugins to convert CSS to unprefixed state. Use them before Autoprefixer:

• postcss-unprefix
• postcss-flexboxfixer
• postcss-gradientfixer

Does Autoprefixer add -epub- prefix?

No, Autoprefixer works only with browsers prefixes from Can I Use. But you can use postcss-epub for prefixing ePub3 properties.

Why doesn’t Autoprefixer transform generic font-family system-ui?

system-ui is technically not a prefix and the transformation is not future-proof. But you can use postcss-font-family-system-ui to transform system-ui to a practical font-family list.

Usage

Gulp

In Gulp you can use gulp-postcss with autoprefixer npm package.

gulp.task('autoprefixer', function () {
    var postcss      = require('gulp-postcss');
    var sourcemaps   = require('gulp-sourcemaps');
    var autoprefixer = require('autoprefixer');

    return gulp.src('./src/*.css')
        .pipe(sourcemaps.init())
        .pipe(postcss([ autoprefixer() ]))
        .pipe(sourcemaps.write('.'))
        .pipe(gulp.dest('./dest'));
});

With gulp-postcss you also can combine Autoprefixer with other PostCSS plugins.

Webpack

In webpack you can use postcss-loader with autoprefixer and other PostCSS plugins.

module.exports = {
    module: {
        loaders: [
            {
                test:   /\.css$/,
                loader: "style-loader!css-loader!postcss-loader"
            }
        ]
    }
}

And create a postcss.config.js with:

module.exports = {
  plugins: [
    require('autoprefixer')
  ]
}

Grunt

In Grunt you can use grunt-postcss with autoprefixer npm package.

module.exports = function(grunt) {
    grunt.loadNpmTasks('grunt-postcss');

    grunt.initConfig({
        postcss: {
            options: {
                map: true,
                processors: [
                    require('autoprefixer')
                ]
            },
            dist: {
                src: 'css/*.css'
            }
        }
    });

    grunt.registerTask('default', ['postcss:dist']);
};

With grunt-postcss you also can combine Autoprefixer with other PostCSS plugins.

Other Build Tools:

• Ruby on Rails: autoprefixer-rails
• Brunch: postcss-brunch
• Broccoli: broccoli-postcss
• Middleman: middleman-autoprefixer
• Mincer: add autoprefixer npm package and enable it: environment.enable('autoprefixer')
• Jekyll: add autoprefixer-rails and jekyll-assets to Gemfile

Preprocessors

• Less: less-plugin-autoprefix
• Stylus: autoprefixer-stylus
• Compass: autoprefixer-rails#compass

CSS-in-JS

There is postcss-js to use Autoprefixer in React Inline Styles, Free Style, Radium and other CSS-in-JS solutions.

let prefixer = postcssJs.sync([ autoprefixer ]);
let style = prefixer({
    display: 'flex'
});

GUI Tools

• CodeKit
• Prepros

CLI

You can use the postcss-cli to run Autoprefixer from CLI:

npm install --global postcss-cli autoprefixer
postcss --use autoprefixer *.css -d build/

See postcss -h for help.

JavaScript

You can use Autoprefixer with PostCSS in your Node.js application or if you want to develop an Autoprefixer plugin for new environment.

var autoprefixer = require('autoprefixer');
var postcss      = require('postcss');

postcss([ autoprefixer ]).process(css).then(function (result) {
    result.warnings().forEach(function (warn) {
        console.warn(warn.toString());
    });
    console.log(result.css);
});

There is also standalone build for the browser or as a non-Node.js runtime.

You can use html-autoprefixer to process HTML with inlined CSS.

Text Editors and IDE

Autoprefixer should be used in assets build tools. Text editor plugins are not a good solution, because prefixes decrease code readability and you will need to change value in all prefixed properties.

I recommend you to learn how to use build tools like Gulp. They work much better and will open you a whole new world of useful plugins and automatization.

But, if you can’t move to a build tool, you can use text editor plugins:

• Sublime Text
• Brackets
• Atom Editor
• Visual Studio

Warnings

Autoprefixer uses the PostCSS warning API to warn about really important problems in your CSS:

• Old direction syntax in gradients.
• Old unprefixed display: box instead of display: flex by latest specification version.

You can get warnings from result.warnings():

result.warnings().forEach(function (warn) {
    console.warn(warn.toString());
});

Every Autoprefixer runner should display this warnings.

Disabling

Autoprefixer was designed to have no interface – it just works. If you need some browser specific hack just write a prefixed property after the unprefixed one.

a {
    transform: scale(0.5);
    -moz-transform: scale(0.6);
}

If some prefixes were generated in a wrong way, please create an issue on GitHub.

Autoprefixer has 4 features, which can be disabled by options:

• supports: false will disable @supports parameters prefixing.
• flexbox: false will disable flexbox properties prefixing. Or flexbox: "no-2009" will add prefixes only for final and IE versions of specification.
• grid: false will disable Grid Layout prefixes for IE.
• remove: false will disable cleaning outdated prefixes.

If you do not need Autoprefixer in some part of your CSS, you can use control comments to disable Autoprefixer.

a {
    transition: 1s; /* it will be prefixed */
}

b {
    /* autoprefixer: off */
    transition: 1s; /* it will not be prefixed */
}

Control comments disable Autoprefixer within the whole rule in which you place it. In the above example, Autoprefixer will be disabled in the entire b rule scope, not only after the comment.

You can also use comments recursively:

/* autoprefixer: off */
@supports (transition: all) {
    /* autoprefixer: on */
    a {
        /* autoprefixer: off */
    }
}

In Sass/SCSS you can use all the disable options above, add an exclamation mark in the start of comment: /*! autoprefixer: off */.

Options

Function autoprefixer(options) returns new PostCSS plugin. See PostCSS API for plugin usage documentation.

var plugin = autoprefixer({ cascade: false });

There are 8 options:

• browsers (array): list of browsers query (like last 2 version), which are supported in your project. We recommend to use browserslist config or browserslist key in package.json, rather than this option to share browsers with other tools. See Browserslist docs for available queries and default value.
• env (string): environment for Browserslist.
• cascade (boolean): should Autoprefixer use Visual Cascade, if CSS is uncompressed. Default: true
• add (boolean): should Autoprefixer add prefixes. Default is true.
• remove (boolean): should Autoprefixer [remove outdated] prefixes. Default is true.
• supports (boolean): should Autoprefixer add prefixes for @supports parameters. Default is true.
• flexbox (boolean|string): should Autoprefixer add prefixes for flexbox properties. With "no-2009" value Autoprefixer will add prefixes only for final and IE versions of specification. Default is true.
• grid (boolean): should Autoprefixer add IE prefixes for Grid Layout properties. Default is true.
• stats (object): custom usage statistics for > 10% in my stats browsers query.

Plugin object has info() method for debugging purpose.

You can use PostCSS processor to process several CSS files to increase performance.

Debug

You can check which browsers are selected and which properties will be prefixed:

var info = autoprefixer().info();
console.log(info);

Changelog

6.7.5

• Fix text-decoration-skip in iOS (by Chi Vinh Le).
• Fix clip-path (by Chi Vinh Le).