CSS matrix() Function

The CSS matrix() function can be used with CSS transforms to style elements in a two-dimensional space.

The matrix() function is an alternative to the two-dimensional transform functions rotate(), skew(), scale(), and translate().

In other words, you can use the matrix() function instead of those functions.

Here's an example of using the matrix() function to move a box to the right and rotate it 45 degrees:

And here's the same effect using the rotate() and translate() functions:

Scaling the Element

Here's an example of using matrix() to scale an element:

And here's the same effect using scale():

How does matrix() Work?

Any time you do a CSS transform, you're affecting the matrix. Even if you use another function such as rotate(), you're still affecting the matrix. The matrix determines the coordinates of the element — its position, size, orientation, etc.

If you click the Computed tab (or equivalent) within your browser's developer tools, you'll probably find that your 2D transforms are actually represented with the matrix() property, even if you didn't actually use that property.

It's a bit like colors. You might specify a color using the color name because it's easy to remember (for example, gold), but the browser might compute that in its RGB equivalent (e.g. rgb(255, 215, 0)).

There's some quite complex (and well established) math behind the way the matrix coordinates are represented. However, you don't need to be a mathematician in order to gain a basic understanding of how the matrix() function works.

The matrix() function accepts six arguments that determine how the element will be transformed.

The arguments work like this:

matrix(a, b, c, d, e, f)

Here's what they're for.

a, d
The arguments a and d represent how the element is scaled in the x and y direction respectively (just like in scale(a, d)).
b, c
The arguments b and c represent how the element is skewed (just like in skew(b, c)).
e, f
The arguments e and f represent how the element is translated in the x and y direction respectively (just like in translate(e, f)).

So, when you create a 2D transform, you could use one of the other 2D transform functions, or you could use the matrix() function with the applicable arguments.

So all of the following lines do the same thing:

/* All three lines have the same result */
scale(2);
scale(2, 2);
matrix(2, 0, 0, 2, 0, 0);

These make the element appear twice as long in both the X and Y axes.

The following two lines do the same thing:

/* Both lines have the same result */
scale(2, 3);
matrix(2, 0, 0, 3, 0, 0);

These make the element appear twice as long in the X axis, and three times as long in the Y axis.

When you use the transform property (and/or its related properties), the transformation is applied to the coordinate system an element renders in. The final transformation value for a coordinate system is obtained by converting each transform function in the list to its corresponding matrix, then multiplying the matrices.

So if we add a translate(10px, 20px) to the above example, we end up with this:

/* Both lines have the same result */
scale(2, 3) translate(10px, 20px);
matrix(2, 0, 0, 3, 20, 60);

Or if we add a rotate(45deg) instead, we end up with this:

/* Both lines have the same result */
scale(2, 3) rotate(45deg);
matrix(1.41421, 2.12132, -1.41421, 2.12132, 0, 0);

So, just as you have a choice in how you apply color to an element, you also have choice in how to apply transforms.

The Order

It's important to note that the order of your transform functions can make a difference to the resulting matrix. For example, if you use a translate() followed by a rotate(), the resulting matrix will be different than if the rotate() had come first.

Example:

/* The functions */
translate(10px, 20px) rotate(60deg);

/* The resulting matrix */
matrix(0.5, 0.866025, -0.866025, 0.5, 10, 20);

Switch them around:

/* The functions */
rotate(60deg) translate(10px, 20px);

/* The resulting matrix */
matrix(0.5, 0.866025, -0.866025, 0.5, -12.3205, 18.6603)

Calculating the Numbers

Even if you know how matrix() works, that doesn't mean you'll know what values to provide it every time you do a transform. As you've seen, the numbers can get quite complex, and you'll need to be able to calculate each argument in your head if you expect to use it in the same way you code the other translation functions.

Fortunately, there are other options for getting the applicable arguments for the matrix() function:

  • One option is to create the transform using the various functions, then get the computed value from your browser's developer tools.
  • Another option is to use the Window.getComputedStyle() method to retrieve the computed value of the transform function.

Here's a quick example of how you can use the Window.getComputedStyle() method:

Official Syntax

The official syntax of the matrix() function is as follows:

matrix() = matrix( <number> [, <number> ]{5,5} )

Possible Values

The matrix() function accepts the six values a-f. Here's what they represent:

a, d
The arguments a and d represent how the element is scaled in the x and y direction respectively (just like in scale(a, d)).
b, c
The arguments b and c represent how the element is skewed (just like in skew(b, c)).
e, f
The arguments e and f represent how the element is translated in the x and y direction respectively (just like in translate(e, f)).

CSS Specifications

Browser Support

The following table provided by Caniuse.com shows the level of browser support for this feature.