# A Beginner’s Introduction to CSS Animation

Nowadays, more and more websites are using animations, whether that be in the form of GIFs, SVGs, WebGL, background videos and so on. When used properly, animation on the web brings life and interactivity, adding an extra layer of feedback and experience for users.

In this tutorial I am going to introduce you to CSS animations; a highly performant way of doing things which is becoming more and more popular as browser support improves. Having covered the basics, we're going to build a quick example which will animate a square element into a circle:

The designers on Envato Market have been busy creating a range of CSS animations for you to plug in to your websites, from shadows to ribbons, sliders, and more.

## An Introduction to @keyframes and Animation

The main component of CSS animations is @keyframes, the CSS rule where animation is created. Think of @keyframes as being stages along a timeline. Inside @keyframes, you can define these stages, each having a different style declaration.

Next, to make CSS animations work, you need to bind the @keyframes to a selector. This will gradually parse all the code inside the @keyframes declarations and change the initial style to the new style, based on the stages.

### The @keyframes

Here we'll set the animation stages. Our @keyframes properties are:

• A name of our choosing (tutsFade in this case).
• Stages: 0%-100%; from (equal to 0%) and to (equal to 100%).
• CSS styles: the style that you would like to apply for each stage.

For example:

 1 @keyframes tutsFade {  2  0% {  3  opacity: 1;  4  }  5  100% {  6  opacity: 0;  7  }  8 } 

or:

 1 @keyframes tutsFade {  2  from {  3  opacity: 1;  4  }  5  to {  6  opacity: 0;  7  }  8 } 

or the shorthand:

 1 @keyframes tutsFade {  2  to {  3  opacity: 0;  4  }  5 } 

The code above will apply a transition to the opacity of an element, from opacity: 1 to opacity: 0. Each of the approaches above will achieve the same end result.

### The Animation

The animation property is used to call @keyframes inside a CSS selector. Animation can have multiple properties:

• animation-name: @keyframes name (remember we chose tutsFade).
• animation-duration: the timeframe length, the total duration of the animation from start to the end.
• animation-timing-function: sets the animation speed ( linear | ease | ease-in | ease-out | ease-in-out | cubic-bezier ).
• animation-delay: the delay before our animation will start.
• animation-iteration-count: how many times it will iterate through animation.
• animation-direction: gives you the ability to change the loop direction, from start to end ,or from end to start, or both.
• animation-fill-mode: specifies which styles will be applied to the element when our animation is finished ( none | forwards | backwards | both )

For example:

 1 .element {  2  animation-name: tutsFade;  3  animation-duration: 4s;  4  animation-delay: 1s;  5  animation-iteration-count: infinite;  6  animation-timing-function: linear;  7  animation-direction: alternate;  8 } 

or shorthand:

 1 .element {  2  animation: tutsFade 4s 1s infinite linear alternate;  3 } 

The code above will create a blinking effect, with a 1 second animation delay, a 4 second total animation duration, with alternate direction and infinite linear loop iterations.

Whilst a working draft, we need to use browser-specific prefixes to ensure the best browser support possible. The standard prefixes apply:

• Chrome & Safari: -webkit-
• Firefox: -moz-
• Opera: -o-
• Internet Explorer: -ms-

An animation property using vendor prefixes will look like:

 1 .element {  2  -webkit-animation: tutsFade 4s 1s infinite linear alternate;  3  -moz-animation: tutsFade 4s 1s infinite linear alternate;  4  -ms-animation: tutsFade 4s 1s infinite linear alternate;  5  -o-animation: tutsFade 4s 1s infinite linear alternate;  6  animation: tutsFade 4s 1s infinite linear alternate;  7 } 

alongside with @keyframes:

 1 @-webkit-keyframes tutsFade { /* your style */ }  2 @-moz-keyframes tutsFade { /* your style */ }  3 @-ms-keyframes tutsFade { /* your style */ }  4 @-o-keyframes tutsFade { /* your style */ }  5 @keyframes tutsFade { /* your style */ } 

For the sake of readability during this tutorial I will continue further without using prefixes, but the final version will include them and I would like to encourage you to use them in your CSS code.

To find out more about vendor prefixes, you can check http://css3please.com/, which is a great website for vendor prefixes resources.

### Multiple Animations

You can add multiple animations using a comma separator. Let’s say that we want to add an additional rotation to our tutsFade element, we'd do so by declaring extra @keyframes and then binding them to our element:

 1 .element {  2  animation: tutsFade 4s 1s infinite linear alternate,  3  tutsRotate 4s 1s infinite linear alternate;  4 }  5 @keyframes tutsFade {  6  to {  7  opacity: 0;  8  }  9 }  10 @keyframes tutsRotate {  11  to {  12  transform: rotate(180deg);  13  }  14 } 

## Square to Circle Tutorial

Let’s jump in and create a simple shape transition; a square to circle animation using the above principles. We will have five stages in total and for each stage we will define a border-radius, a rotation and a different background color to our element. Enough talking, let’s jump into coding.

### Basic Element

First, let’s create the markup, an element to animate. We're not even going to bother with class names, we're just going to use a plain div for now:

 1 


Then, using an element selector (div {}), add default styling to the div:

 1 div {  2  width: 200px;  3  height: 200px;  4  background-color: coral;  5 } 

### Declaring the Keyframes

Now let’s prepare @keyframes, which we'll call square-to-circle, and the five stages

 1 @keyframes square-to-circle {  2  0%{}  3  25%{}  4  50%{}  5  75%{}  6  100%{}  7 } 

We need to define some styes within these stages, so let's begin by dictating the border-radius for each corner of the square:

 1 @-webkit-keyframes square-to-circle {  2  0% {  3  border-radius:0 0 0 0;  4  }  5  25% {  6  border-radius:50% 0 0 0;  7  }  8  50% {  9  border-radius:50% 50% 0 0;  10  }  11  75% {  12  border-radius:50% 50% 50% 0;  13  }  14  100% {  15  border-radius:50%;  16  }  17 } 

Additionally we can declare a different background-color for each stage.

 1 @keyframes square-to-circle {  2  0% {  3  border-radius:0 0 0 0;  4  background:coral;  5  }  6  25% {  7  border-radius:50% 0 0 0;  8  background:darksalmon;  9  }  10  50% {  11  border-radius:50% 50% 0 0;  12  background:indianred;  13  }  14  75% {  15  border-radius:50% 50% 50% 0;  16  background:lightcoral;  17  }  18  100% {  19  border-radius:50%;  20  background:darksalmon;  21  }  22 } 

To really hit the idea home, let's go beyond border-radius and background-color by rotating the div and adding a little visual interest.

 1 @keyframes square-to-circle {  2  0% {  3  border-radius:0 0 0 0;  4  background:coral;  5  transform:rotate(0deg);  6  }  7  25% {  8  border-radius:50% 0 0 0;  9  background:darksalmon;  10  transform:rotate(45deg);  11  }  12  50% {  13  border-radius:50% 50% 0 0;  14  background:indianred;  15  transform:rotate(90deg);  16  }  17  75% {  18  border-radius:50% 50% 50% 0;  19  background:lightcoral;  20  transform:rotate(135deg);  21  }  22  100% {  23  border-radius:50%;  24  background:darksalmon;  25  transform:rotate(180deg);  26  }  27 } 

### Apply the Animation

Having defined our square-to-circle animation, we need to apply it to the div:

 1 div {  2  width: 200px;  3  height: 200px;  4  background-color: coral;  5  animation: square-to-circle 2s 1s infinite alternate;  6 } 

Here you see we've added a shorthand animation property, which states:

• The animation-name is square-to-circle.
• The animation-duration is 2s.
• The animation-delay is 1s.
• The animation-iteration-count is infinite, so it will carry on indefinitely.
• And the animation-direction is alternate, so it will play from beginning to end, then back to the beginning, then again to the end, and so on.

### Use Timing-Function Awesomeness

One last value we can add to the animation property is the animation-timing-function. This will define the speed, acceleration and deceleration of our movement. This function can be a very detailed value, which is awkward to calculate manually, but there are a lot of free websites which provide resources and live customisation for animation timing functions.

One such tool is the CSS Easing Animation Tool, so let's use that to calculate our timing function.

I would like to add an elastic effect to our square-to-circle animation, using a cubic-bezier function.

Having played around with the handles and generated some kind of bezier curve, update the animation timing-function value using the snippet provided.

 1 div {  2  width: 200px;  3  height: 200px;  4  background-color: coral;  5  animation: square-to-circle 2s 1s infinite cubic-bezier(1,.015,.295,1.225) alternate;  6 } 

The final code, without using vendor prefixes ( -webkit- , -moz-, -ms-, -o- ) is as follows:

 1 div {  2  width: 200px;  3  height: 200px;  4  background-color: coral;  5  animation: square-to-circle 2s .5s infinite cubic-bezier(1,.015,.295,1.225) alternate;  6 }  7 8 @keyframes square-to-circle {  9  0% {  10  border-radius:0 0 0 0;  11  background:coral;  12  transform:rotate(0deg);  13  }  14  25% {  15  border-radius:50% 0 0 0;  16  background:darksalmon;  17  transform:rotate(45deg);  18  }  19  50% {  20  border-radius:50% 50% 0 0;  21  background:indianred;  22  transform:rotate(90deg);  23  }  24  75% {  25  border-radius:50% 50% 50% 0;  26  background:lightcoral;  27  transform:rotate(135deg);  28  }  29  100% {  30  border-radius:50%;  31  background:darksalmon;  32  transform:rotate(180deg);  33  }  34 } 

## One Last Thing

All works well in modern browsers, but Firefox has a nasty habit of rendering transforming objects poorly. Take a look at these jagged lines to see what I mean:

Luckily, there's a workaround for this. Add the following transparent outline to your div and Firefox will render things perfectly!

 1 outline: 1px solid transparent; 

## Conclusion

That's it! We've used CSS Animation syntax to create a simple, repeating animation.

### Browser Support

For up-to-date information on the browsers support for CSS animation, check out Can I use.. but in a nutshell, supporting browsers include: Firefox 5+, IE 10+, Chrome, Safari 4+, Opera 12+.