index.md

---
title: animation-timing-function
slug: Web/CSS/animation-timing-function
page-type: css-property
browser-compat: css.properties.animation-timing-function
---

{{CSSRef}}

The **`animation-timing-function`**[CSS](/en-US/docs/Web/CSS) property sets how an animation progresses through the duration of each cycle.

{{InteractiveExample("CSS Demo: animation-timing-function")}}

```css interactive-example-choice
animation-timing-function: linear;
```

```css interactive-example-choice
animation-timing-function: ease-in-out;
```

```css interactive-example-choice
animation-timing-function: steps(5, end);
```

```css interactive-example-choice
animation-timing-function: cubic-bezier(0.1, -0.6, 0.2, 0);
```

```html interactive-example
<sectionclass="flex-column"id="default-example">
 <divclass="animating"id="example-element"></div>
 <buttonid="play-pause">Play</button>
</section>
```

```css interactive-example
#example-element {
animation-duration: 3s;
animation-iteration-count: infinite;
animation-name: slide;
animation-play-state: paused;
background-color: #1766aa;
border-radius: 50%;
border: 5pxsolid#333;
color: white;
height: 150px;
margin: auto;
margin-left: 0;
width: 150px;
}

#example-element.running {
animation-play-state: running;
}

#play-pause {
font-size: 2rem;
}

@keyframesslide {
from {
background-color: orange;
color: black;
margin-left: 0;
 }
to {
background-color: orange;
color: black;
margin-left: 80%;
 }
}
```

```js interactive-example
"use strict";

window.addEventListener("load", () => {
constel=document.getElementById("example-element");
constbutton=document.getElementById("play-pause");

button.addEventListener("click", () => {
if (el.classList.contains("running")) {
el.classList.remove("running");
button.textContent="Play";
 } else {
el.classList.add("running");
button.textContent="Pause";
 }
 });
});
```

It is often convenient to use the shorthand property {{cssxref("animation")}} to set all animation properties at once.

## Syntax

```css
/* Keyword values */
animation-timing-function: ease;
animation-timing-function: ease-in;
animation-timing-function: ease-out;
animation-timing-function: ease-in-out;
animation-timing-function: linear;
animation-timing-function: step-start;
animation-timing-function: step-end;

/* cubic-bezier() function values */
animation-timing-function: cubic-bezier(0.42, 0, 1, 1); /* ease-in */
animation-timing-function: cubic-bezier(0, 0, 0.58, 1); /* ease-out */
animation-timing-function: cubic-bezier(0.42, 0, 0.58, 1); /* ease-in-out */

/* linear() function values */
animation-timing-function: linear(0, 0.25, 1);
animation-timing-function: linear(0 0%, 0.25 50%, 1 100%);
animation-timing-function: linear(0, 0.25 50% 75%, 1);
animation-timing-function: linear(0, 0.25 50%, 0.25 75%, 1);

/* steps() function values */
animation-timing-function: steps(4, jump-start);
animation-timing-function: steps(10, jump-end);
animation-timing-function: steps(20, jump-none);
animation-timing-function: steps(5, jump-both);
animation-timing-function: steps(6, start);
animation-timing-function: steps(8, end);

/* Multiple animations */
animation-timing-function: ease, step-start, cubic-bezier(0.1, 0.7, 1, 0.1);

/* Global values */
animation-timing-function: inherit;
animation-timing-function: initial;
animation-timing-function: revert;
animation-timing-function: revert-layer;
animation-timing-function: unset;
```

### Values

- {{cssxref("&lt;easing-function&gt;")}}

 - : The easing function that corresponds to a given animation, as determined by {{cssxref("animation-name")}}.

 The non-step keyword values (`ease`, `linear`, `ease-in-out`, etc.) each represent cubic Bézier curves with fixed four-point values, while the `cubic-bezier()` function value allows non-predefined values to be specified. The `steps()` easing function divides the inputtime into a specified number of equal-length intervals. Its parameters include a number of steps and a step position.

 - `linear`
 - : Equal to `cubic-bezier(0.0, 0.0, 1.0, 1.0)`, animates at an even speed.
 - `ease`
 - : Equal to `cubic-bezier(0.25, 0.1, 0.25, 1.0)`, the default value, increases in velocity towards the middle of the animation, slowing back down at the end.
 - `ease-in`
 - : Equal to `cubic-bezier(0.42, 0, 1.0, 1.0)`, starts off slowly, with the speed of the transition of the animating property increasing until complete.
 - `ease-out`
 - : Equal to `cubic-bezier(0, 0, 0.58, 1.0)`, starts quickly, slowing down the animation continues.
 - `ease-in-out`

 - : Equal to `cubic-bezier(0.42, 0, 0.58, 1.0)`, with the animating properties slowly transitioning, speeding up, and then slowing down again.

 - `cubic-bezier(<number [0,1]> , <number> , <number [0,1]> , <number>)`

 - : An author defined cubic-bezier curve, where the first and third values must be in the range of 0 to 1.

 - `linear(<number> <percentage>{1,2}, …)`

 - : The function interpolates linearly between the provided easing stop points. Astop point is a pair of an outputprogress and an input percentage. The input percentage is optional and is inferred if not specified. If an input percentage is not provided then the first and last stop points are set to `0%` and `100%` respectively, and the stop points in the middle receive percentage values derived by linearly interpolating between the closest previous and next points that have a percentage value.

 - `steps(<integer>, <step-position>)`

 - : Displays an animation iteration along _n_ stops along the transition, displaying each stop for equal lengths of time. For example, if _n_ is 5, there are 5 steps. Whether the animation holds temporarily at 0%, 20%, 40%, 60% and 80%, on the 20%, 40%, 60%, 80% and 100%, or makes 5 stops between the 0% and 100% along the animation, or makes 5 stops including the 0% and 100% marks (on the 0%, 25%, 50%, 75%, and 100%) depends on which of the following step position is used:

 - `jump-start`
 - : Denotes aleft-continuous function, so that the first jump happens when the animation begins.
 - `jump-end`
 - : Denotes aright-continuous function, so that the last jump happens when the animation ends. This is the default.
 - `jump-none`
 - : There is no jump on either end, effectively removing a step during the interpolation iteration. Instead, it holds at both the 0% mark and the 100% mark, each for 1/n of the duration.
 - `jump-both`
 - : Includes pauses at both the 0% and 100% marks, effectively adding a step during the animation iteration.
 - `start`
 - : Same as `jump-start`.
 - `end`
 - : Same as `jump-end`.

 - `step-start`
 - : Equal to `steps(1, jump-start)`
 - `step-end`
 - : Equal to `steps(1, jump-end)`

> [!NOTE]
> When you specify multiple comma-separated values on an `animation-*` property, they are applied to the animations in the order in which the {{cssxref("animation-name")}}s appear. For situations where the number of animations and `animation-*` property values do not match, see [Setting multiple animation property values](/en-US/docs/Web/CSS/CSS_animations/Using_CSS_animations#setting_multiple_animation_property_values).

>**Note:** `animation-timing-function` has the same effect when creating [CSS scroll-driven animations](/en-US/docs/Web/CSS/CSS_scroll-driven_animations) as it does for regular time-based animations.

## Description

Easing functions may be specified on individual keyframes in a {{cssxref("@keyframes")}} rule. If no **`animation-timing-function`** is specified on a keyframe, the corresponding value of **`animation-timing-function`** from the element to which the animation is applied is used for that keyframe.

Within a keyframe, `animation-timing-function` is an at-rule-specific descriptor, not the property of the same name. The timing is not being animated. Rather, a keyframe's easing function is applied on aproperty-by-property basis from the keyframe on which it is specified until the next keyframe specifying that property, or until the end of the animation if there is no subsequent keyframe specifying that property. As a result, an **`animation-timing-function`** specified on the **`100%`** or **`to`** keyframe will never be used.

## Formal definition

{{cssinfo}}

## Formal syntax

{{csssyntax}}

## Examples

All the examples in this sectionanimate the `width` and `background-color` properties of several `<div>` elements with different `animation-timing-function` values. The width is being animated from `0` to `100%`, and the background color is being animated from lime to magenta.

### Linear function examples

The example demonstrates the effects of various `linear()` easing function values.

```html hidden
<div class="parent">
 <div class="linear">'linear' value</div>
 <div class="linear-fn1">linear(0, 0.5 50%, 1)</div>
 <div class="linear-fn2">linear(0, 0.25 75%, 1)</div>
 <div class="linear-fn3">linear(0, 0.75 25%, 1)</div>
 <div class="linear-fn4">linear(0, 0.5 25% 75%, 1)</div>
 <div class="linear-fn5">linear(0, 0.25 45%, 0.75 55%, 0.5 70%, 1)</div>
 <div class="linear-fn6">linear(0, 1.2 50%, 0.75 80%, 1)</div>
 <div class="linear-fn7">linear(0, 0.5 75%, 1 120%)</div>
</div>
<div class="x-axis"><span>25%</span><span>50%</span><span>75%</span></div>
<button>Play animation</button>
```

```js hidden
const btn = document.querySelector("button");
const divs = document.querySelectorAll(".parent>div[class]");

btn.addEventListener("click", () => {
btn.setAttribute("disabled", "true");
for (constdivofdivs) {
div.classList.remove("animate");
voiddiv.offsetWidth;
div.classList.add("animate");
 }
 setTimeout(() => {
btn.removeAttribute("disabled");
 }, 11000);
});
```

```css hidden
.x-axis {
display: flex;
justify-content: space-evenly;
width: 80vw;
margin-left: 4px;
}

.parent {
background: linear-gradient(
toright,
white24.8%,
grey24.8%,
grey25.2%,
white25.2%,
white49.8%,
grey49.8%,
grey50.2%,
white50.2%,
white74.8%,
grey74.8%,
grey75.2%,
white75.2%
 );
width: 80vw;
font-family: monospace;
font-weight: bold;
border: 2pxsolidgrey;
}

.animate {
animation-name: changeme;
}

.parent>div[class] {
animation-fill-mode: forwards;
animation-duration: 10s;

width: 0;
margin-bottom: 4px;
padding: 5px0;
box-sizing: border-box;
text-wrap: nowrap;
background-color: lime;
}

@keyframeschangeme {
0% {
width: 0em;
 }
100% {
width: 100%;
background-color: orange;
 }
}

.linear {
animation-timing-function: linear;
}
.linear-fn1 {
animation-timing-function: linear(0, 0.550%, 1);
}
.linear-fn2 {
animation-timing-function: linear(0, 0.2575%, 1);
}
.linear-fn3 {
animation-timing-function: linear(0, 0.7525%, 1);
}
.linear-fn4 {
animation-timing-function: linear(0, 0.525%75%, 1);
}
.linear-fn5 {
animation-timing-function: linear(0, 0.2545%, 0.7555%, 0.570%, 1);
}
.linear-fn6 {
animation-timing-function: linear(0, 1.250%, 0.7580%, 1);
}
.linear-fn7 {
animation-timing-function: linear(0, 0.575%, 1120%);
}
```

{{EmbedLiveSample("Linear function examples", 600, 300)}}

The following image shows graphs of all the `linear()` function values used in this example. Input progress (time) is plotted on the x-axis and output progress is plotted on the y-axis. As per the syntax, the input progress ranges from 0 to 100%, and the output ranges from 0 to 1.

![An image showing 'linear' function graphs](https://mdn.github.io/shared-assets/images/diagrams/css/animation-easing/linear-function-graphs.png)

Note that the output can go forward or backward.

### Cubic-Bézier examples

The example demonstrates the effects of various bézier curve easing functions.

```html hidden
<divclass="parent">
 <divclass="linear">linear</div>
 <divclass="ease">ease</div>
 <divclass="ease-in">ease-in</div>
 <divclass="ease-out">ease-out</div>
 <divclass="ease-in-out">ease-in-out</div>
 <divclass="cb">cubic-bezier(.5, -0.5, 1, 1.5)</div>
</div>
<divclass="x-axis"><span>50%</span></div>
<button>Play animation</button>
```

```js hidden
constbtn=document.querySelector("button");
constdivs=document.querySelectorAll(".parent > div[class]");

btn.addEventListener("click", () => {
btn.setAttribute("disabled", "true");
for (constdivof divs) {
div.classList.remove("animate");
voiddiv.offsetWidth;
div.classList.add("animate");
 }
setTimeout(() => {
btn.removeAttribute("disabled");
 }, 11000);
});
```

```css hidden
.x-axis {
display: flex;
justify-content: space-evenly;
width: 80vw;
margin-left: 4px;
}

.parent {
background: linear-gradient(
toright,
white49.8%,
grey49.8%,
grey50.2%,
white50.2%
 );
width: 80vw;
font-family: monospace;
font-weight: bold;
border: 2pxsolidgrey;
}

.animate {
animation-name: changeme;
}

.parent>div[class] {
animation-fill-mode: forwards;
animation-duration: 10s;

width: 0;
margin-bottom: 4px;
padding: 5px0;
box-sizing: border-box;
text-wrap: nowrap;
background-color: lime;
}

@keyframeschangeme {
0% {
width: 0em;
 }
100% {
width: 100%;
background-color: orange;
 }
}

.linear {
animation-timing-function: linear;
}
.ease {
animation-timing-function: ease;
}
.ease-in {
animation-timing-function: ease-in;
}
.ease-out {
animation-timing-function: ease-out;
}
.ease-in-out {
animation-timing-function: ease-in-out;
}
.cb {
animation-timing-function: cubic-bezier(0.5, -0.5, 1, 1.5);
}
```

{{EmbedLiveSample("Cubic-Bezier_examples", 600, 250)}}

The following image shows graphs of all the cubic bézier function values used in this example. The input progress (time) ranges from 0 to 1 and the output progress ranges from 0 to 1.

![An image showing 'cubic-bezier' function graphs](https://mdn.github.io/shared-assets/images/diagrams/css/animation-easing/cubic-bezier-function-graphs.png)

### Step examples

This example demonstrates the effects of several step easing function values.

```html hidden
<divclass="parent">
 <divclass="linear">linear</div>
 <divclass="start">steps(4, start)</div>
 <divclass="jump-start">steps(4, jump-start)</div>
 <divclass="end">steps(4, end)</div>
 <divclass="jump-end">steps(4, jump-end)</div>
 <divclass="jump-both">steps(4, jump-both)</div>
 <divclass="jump-none">steps(4, jump-none)</div>
 <divclass="step-start">step-start</div>
 <divclass="step-end">step-end</div>
</div>
<divclass="x-axis"><span>25%</span><span>50%</span><span>75%</span></div>
<button>Play animation</button>
```

```js hidden
constbtn=document.querySelector("button");
constdivs=document.querySelectorAll(".parent > div[class]");

btn.addEventListener("click", () => {
btn.setAttribute("disabled", "true");
for (constdivof divs) {
div.classList.remove("animate");
voiddiv.offsetWidth;
div.classList.add("animate");
 }
setTimeout(() => {
btn.removeAttribute("disabled");
 }, 11000);
});
```

```css hidden
.x-axis {
display: flex;
justify-content: space-evenly;
width: 80vw;
margin-left: 4px;
}

.parent {
background: linear-gradient(
toright,
white24.8%,
grey24.8%,
grey25.2%,
white25.2%,
white49.8%,
grey49.8%,
grey50.2%,
white50.2%,
white74.8%,
grey74.8%,
grey75.2%,
white75.2%
 );
width: 80vw;
font-family: monospace;
font-weight: bold;
border: 2pxsolidgrey;
}

.animate {
animation-name: changeme;
}

.parent>div[class] {
animation-fill-mode: forwards;
animation-duration: 10s;

width: 0;
margin-bottom: 4px;
padding: 5px0;
box-sizing: border-box;
text-wrap: nowrap;
background-color: lime;
}

@keyframeschangeme {
0% {
width: 0em;
 }
100% {
width: 100%;
background-color: orange;
 }
}
```

```css hidden
.linear {
animation-timing-function: linear;
}

.start {
animation-timing-function: steps(4, start);
}
.jump-start {
animation-timing-function: steps(4, jump-start);
}
.end {
animation-timing-function: steps(4, end);
}
.jump-end {
animation-timing-function: steps(4, jump-end);
}
.jump-both {
animation-timing-function: steps(4, jump-both);
}
.jump-none {
animation-timing-function: steps(4, jump-none);
}
.step-start {
animation-timing-function: step-start;
}
.step-end {
animation-timing-function: step-end;
}
```

{{EmbedLiveSample("Step_examples", 600, 350)}}

The following image shows graphs of all the `step()` function values used in this example. The input progress (time) and output progress range from 0 to 1.

![image showing 'steps' function graphs](https://mdn.github.io/shared-assets/images/diagrams/css/animation-easing/step-function-graphs.png)

## Specifications

{{Specifications}}

## Browser compatibility

{{Compat}}

## See also

-[Using CSS animations](/en-US/docs/Web/CSS/CSS_animations/Using_CSS_animations)
- {{cssxref('easing-function')}}
- JavaScript {{domxref("AnimationEvent")}} API
-[Cubic bézier generation tool](https://cubic-bezier.com/)
- Other related animation properties: {{cssxref("animation")}}, {{cssxref("animation-composition")}}, {{cssxref("animation-delay")}}, {{cssxref("animation-direction")}}, {{cssxref("animation-duration")}}, {{cssxref("animation-fill-mode")}}, {{cssxref("animation-iteration-count")}}, {{cssxref("animation-name")}}, {{cssxref("animation-play-state")}}, {{cssxref("animation-timeline")}}