CSS animations
CSS Animations is a module of the Cascading Style Sheets (CSS) language that enables web authors to animate the values of CSS properties over time, creating smooth transitions and dynamic effects on HTML elements without requiring JavaScript.[1]
Introduced as part of CSS3, the specification for CSS Animations Level 1 was first published by the World Wide Web Consortium (W3C) as a Working Draft on 20 March 2009, aiming to provide explicit control over animations beyond the simpler implicit changes offered by CSS Transitions.[2] The module has evolved through multiple drafts, with the most recent substantive updates in the 2 March 2023 Working Draft, incorporating refinements to keyframe assembly, animation events, and integration with the broader Web Animations model.[1] CSS Animations Level 2, also published as a Working Draft on 2 March 2023, further extends these capabilities with enhanced synchronization to the Web Animations API.[3]
At its core, CSS Animations work by defining a set of keyframes using the @keyframes at-rule, which specifies intermediate property values at points ranging from 0% (or from) to 100% (or to), allowing for complex, multi-step sequences such as rotating elements or fading opacity.[1] These animations are then applied to elements via the shorthand animation property or its longhand variants—like animation-duration for timing length, animation-timing-function for easing curves (e.g., ease-in-out), animation-iteration-count for repeats, animation-direction for playback order, and animation-delay for onset timing—enabling precise control over behavior.
Key features include support for fill modes to apply styles before or after the animation runs, pausing via animation-play-state, and triggering DOM events such as animationstart, animationiteration, and animationend for synchronization with scripts.[1] Unlike scripted animations, CSS Animations are optimized for performance, often leveraging GPU acceleration in browsers to ensure 60 frames-per-second smoothness on properties like transform and opacity, which reduces main-thread blocking and improves perceived responsiveness.[4]
Browser compatibility is robust across modern platforms, with full support in Chrome since version 4 (2010), Firefox since version 5 (2011), Safari since version 5.1 (2010), and Edge since version 12 (2015), covering over 97% of global users without prefixes (as of 2025).[5] This widespread adoption has made CSS Animations a cornerstone of web design, facilitating engaging user interfaces while maintaining accessibility and efficiency.[6]
Fundamentals
Overview
CSS animations provide a native method for creating smooth transitions and movements of HTML elements directly through CSS, eliminating the need for JavaScript intervention. This technique allows developers to define a sequence of style changes over specified durations, enabling elements to gradually shift from one visual state to another, such as rotating, scaling, or fading. By specifying animation rules, web pages can incorporate dynamic effects that respond to user interactions or page events, all handled declaratively within stylesheets.
The primary benefits of CSS animations include enhanced user experience through intuitive visual cues that guide attention and provide feedback, such as button hovers or loading indicators. They also minimize reliance on scripting languages like JavaScript, which can complicate codebases and increase maintenance overhead, while supporting hardware acceleration in browsers for efficient rendering on the GPU rather than the CPU. This results in smoother performance and better battery life on mobile devices, making animations more accessible and performant for a wider audience.[4]
Compared to JavaScript-based animations, which excel in complex, interactive scenarios requiring runtime calculations, CSS animations offer a simpler, declarative alternative for straightforward effects, promoting cleaner separation of concerns between styling and logic. In contrast to GIFs, which rely on pre-rendered raster frames that inflate file sizes and lack scalability on high-DPI screens, CSS animations generate content dynamically, ensuring crisp visuals without additional downloads. For instance, a basic fade-in animation can progressively increase an element's opacity from 0 to 1 upon page load, creating a subtle entrance effect that aids user comprehension without overwhelming the interface.[7][8]
Key Concepts
CSS animations operate by transitioning CSS property values between specified states over a defined timeline, enabling smooth visual changes without relying on JavaScript. The core animation states are established through keyframes, which define the start ("from"), end ("to"), and any intermediate points of progression. The "from" keyframe represents the initial state at 0% completion, while the "to" keyframe denotes the final state at 100%; intermediate keyframes, specified at percentage offsets (e.g., 50%), interpolate values between these points to create fluid motion.[9]
Animations can repeat through the concept of iteration, where the number of cycles is controlled by the repetition count, allowing for finite (e.g., a specific integer like 3) or infinite loops. The direction of these iterations further refines behavior: "normal" proceeds forward each time, "reverse" plays backward from start to end, "alternate" switches direction after each cycle (forward then backward), and "alternate-reverse" begins with a backward direction before alternating.[10][11]
To manage behavior outside the active animation period, fill modes determine how styles are applied before the animation begins and after it completes. The "none" mode applies no special styles, reverting to normal CSS rules; "forwards" holds the final keyframe values indefinitely after ending; "backwards" applies the initial keyframe values during any delay before starting; and "both" combines the effects of forwards and backwards for comprehensive control.[12]
At the heart of these mechanics is the animation timeline, which governs the progression from initiation to completion and synchronizes with the browser's rendering cycle. The timeline begins once the animation is fully resolved (e.g., when keyframes are linked), advancing in real time unless paused, and influences the computed values in the CSS cascade—overriding ordinary declarations but yielding to !important rules—before being rendered on interactive mediums like screens.[13][14]
Syntax and Implementation
Keyframe Declarations
Keyframe declarations in CSS animations are defined using the @keyframes at-rule, which allows authors to specify the intermediate steps of an animation sequence by setting property values at specific points in time. The syntax for the @keyframes rule is @keyframes <keyframes-name> { <rule-list> }, where <keyframes-name> is a <custom-ident> (an identifier) or a <string>, and <rule-list> contains one or more keyframe blocks.[9] This name is case-sensitive and must match the value used in the animation-name property to apply the animation to an element.[15]
Within the @keyframes rule, property changes are specified using keyframe selectors such as from (equivalent to 0%), to (equivalent to 100%), or percentage values between 0% and 100% (e.g., 25%, 50%) to denote the progress points along the animation timeline.[16] Each selector is followed by a block of CSS declarations that define the styles to interpolate between keyframes; for instance, at 0%, an element might start with opacity: 1, transitioning to opacity: 0 at 100%.[15] These declarations can include any animatable CSS properties, and the browser automatically computes intermediate values using easing functions for smooth transitions.[9]
Multiple keyframe blocks can be defined within a single @keyframes rule, and if multiple blocks share the same selector (e.g., two at 50%), their declarations are merged, with later rules overriding earlier ones in document order.[17] Additionally, multiple @keyframes rules with the same name can exist in a stylesheet, but only the last one in document order is used, ignoring duplicates.[9] For broader browser compatibility, especially in older versions of WebKit-based browsers like Safari, vendor-prefixed versions such as @-webkit-keyframes were historically required alongside the standard rule.[15]
The following example demonstrates a keyframe declaration for a rotating element using the transform property:
css
@keyframes rotate {
from {
transform: rotate(0deg);
}
to {
transform: rotate(360deg);
}
}
@keyframes rotate {
from {
transform: rotate(0deg);
}
to {
transform: rotate(360deg);
}
}
This defines an animation named "rotate" that spins an element a full circle, with the starting position at 0 degrees and the end at 360 degrees.[15] Timing aspects, such as duration, are controlled separately via properties like animation-duration when applying the keyframes to an element.[18]
Animation Properties
CSS animations are configured and applied to elements using a set of dedicated properties that control various aspects of the animation's behavior, such as its name, duration, and timing. These properties allow developers to link animations defined via keyframes to specific HTML elements and fine-tune their execution without altering the underlying keyframe definitions. The core properties include animation-name, which identifies the keyframe animation to apply; animation-duration, which sets the length of one animation cycle; and animation-timing-function, which defines the speed curve of the animation.[1]
The animation-name property accepts a value of none or the name of a keyframe rule, linking the element to the specified animation sequence defined elsewhere in the stylesheet. For instance, if a keyframe set named "slide" is declared, setting animation-name: slide; on an element will apply that animation. This property applies to all elements and has an initial value of none.[1] The animation-duration property specifies the time for one complete cycle, using time units like seconds (s) or milliseconds (ms), with values ranging from 0s to infinity; a value of 0s effectively disables the animation. It defaults to 0s and applies to all elements. An example usage is animation-duration: 3s;, which runs the animation over three seconds.[1] Meanwhile, animation-timing-function determines how the animation progresses over time, accepting easing functions such as predefined keywords (ease, linear), cubic-bezier() for custom curves, or steps() for stepped motion; its initial value is ease. This property also applies to all elements.[1]
A comprehensive shorthand property, animation, combines most individual animation properties into a single declaration for convenience, in the order: animation-name, animation-duration, animation-timing-function, animation-delay, animation-iteration-count, animation-direction, animation-fill-mode, animation-play-state. Omitted values inherit their initial settings. For example, animation: slide 3s ease-in 1s infinite alternate both paused; applies a named animation "slide" with a 3-second duration, ease-in timing, 1-second delay, infinite iterations alternating direction, forwards and backwards fill modes, and a paused initial state. This shorthand applies to all elements and simplifies code while maintaining full control over animation configuration.[1][19]
To ensure cross-browser compatibility, especially in older versions of WebKit-based browsers like Safari and early Chrome, vendor-prefixed versions of these properties—such as -webkit-animation-name, -webkit-animation-duration, and the -webkit-animation shorthand—are recommended alongside the standard unprefixed properties. Modern browsers support the standard properties without prefixes since around 2015, but prefixes remain useful for legacy support. For instance, a declaration might include both: -webkit-animation: slide 3s ease-in; animation: slide 3s ease-in;.[19]
Multiple animations can be applied to a single element by providing comma-separated lists of values for any animation property, allowing independent control over each. The lists must have the same length for consistency across properties; shorter lists pad with none. An example is animation: slidein 3s linear 0s 1 normal, slideout 3s ease-out 5s 1 reverse;, which sequences a "slidein" animation followed by a delayed "slideout" on the same element. This feature enables complex effects without additional elements.[19]
| Property | Purpose | Initial Value | Applies To |
|---|
| animation-name | Links to keyframe animation name | none | All elements |
| animation-duration | Sets cycle length (e.g., 5s) | 0s | All elements |
| animation-timing-function | Defines progression curve (e.g., cubic-bezier) | ease | All elements |
| animation (shorthand) | Combines name, duration, timing, delay, iteration, direction, fill-mode, play-state | See individuals | All elements |
Timing and Control
Duration and Delay
The animation-duration property in CSS specifies the length of time required to complete one cycle of an animation, accepting absolute time units such as seconds (s) or milliseconds (ms), for example, 2s or 500ms. The default value is 0s, which effectively disables the animation by providing no time for it to run. Using longer durations, such as 3s instead of 1s for the same keyframe changes, can enhance perceived smoothness by distributing the transformation over more frames, assuming the browser's rendering capabilities align with typical display refresh rates of 60Hz or higher.
In contrast, the animation-delay property controls the offset before the animation begins its first cycle, also using absolute time units like s or ms. Positive values, such as 1s, postpone the start to create a buildup effect, while negative values, like -0.5s, simulate an animation that has partially progressed, jumping immediately to an intermediate state. The default is 0s, which is commonly used in scenarios requiring synchronized starts across multiple elements without any initial pause, such as in simultaneous fade-ins.
When combined with the animation-iteration-count property, animation-duration and animation-delay determine the overall timeline of an animation sequence. The delay applies only once at the outset, after which the animation runs for the specified duration per iteration; thus, the total elapsed time from initiation to completion is the delay plus the product of duration and iteration count (e.g., for a 2s duration, 1s delay, and 3 iterations, the full cycle spans 1s + (2s × 3) = 7s). This interaction allows for predictable sequencing, though iteration details are covered in key concepts.
A practical application of these properties is in creating staggered effects for lists, where each item's animation-delay increases incrementally to produce a sequential reveal. For instance, consider a CSS rule set for an unordered list:
css
.list-item {
animation: slideIn 0.5s ease-out forwards;
animation-duration: 0.5s;
}
.list-item:nth-child(1) { animation-delay: 0s; }
.list-item:nth-child(2) { animation-delay: 0.1s; }
.list-item:nth-child(3) { animation-delay: 0.2s; }
/* And so on */
.list-item {
animation: slideIn 0.5s ease-out forwards;
animation-duration: 0.5s;
}
.list-item:nth-child(1) { animation-delay: 0s; }
.list-item:nth-child(2) { animation-delay: 0.1s; }
.list-item:nth-child(3) { animation-delay: 0.2s; }
/* And so on */
Here, the uniform 0.5s duration ensures consistent slide speed, while the progressive delays (0s, 0.1s, 0.2s) offset starts to mimic a cascading animation, enhancing visual flow without requiring JavaScript. Longer durations in such setups can further smooth the motion across devices, though excessive lengths may impact perceived responsiveness.
Easing Functions
Easing functions in CSS animations define the rate of change in an animation's progress over time, allowing for more natural and fluid motion by accelerating or decelerating elements rather than progressing at a constant speed. These functions map input progress (from 0 to 1, representing the animation's timeline) to output progress, creating curves that simulate real-world physics like inertia or sudden stops. By applying easing, developers can avoid mechanical, uniform animations and instead achieve effects that feel intuitive and engaging.[20]
CSS provides several built-in keywords for common easing patterns, each corresponding to a predefined cubic Bézier curve. The ease keyword, which is the default, starts slowly, accelerates in the middle, and decelerates toward the end, equivalent to cubic-bezier(0.25, 0.1, 0.25, 1). The linear keyword maintains a constant speed throughout, matching cubic-bezier(0, 0, 1, 1). For acceleration from the start, ease-in begins slowly and speeds up, defined as cubic-bezier(0.42, 0, 1, 1). Conversely, ease-out starts quickly and decelerates to a smooth stop, using cubic-bezier(0, 0, 0.58, 1), which is particularly useful for simulating decelerating scrolls or landing effects in user interfaces. The ease-in-out keyword combines both, with slow starts and ends but faster progression in between, represented by cubic-bezier(0.42, 0, 0.58, 1).[20][21]
For more customized motion, the cubic-bezier() function allows developers to define their own curves using four control points: P0 at (0, 0) and P3 at (1, 1), with P1 and P2 determining the curve's shape through their x and y coordinates (x values between 0 and 1, y values unrestricted). This enables precise control over acceleration and deceleration; for instance, cubic-bezier(0.25, 0.1, 0.25, 1) replicates the ease behavior, while variations like cubic-bezier(0.68, -0.55, 0.265, 1.55) can create bouncy overshoots. The curve is plotted with time (input) on the x-axis and progress (output) on the y-axis, visualizing how the animation interpolates between keyframes.[20][21]
When smooth curves are unsuitable, the steps() function produces discrete jumps by dividing the animation into a specified number of equal intervals, holding the output constant between steps. Its syntax is steps(<integer>, <step-position>), where the integer sets the number of steps (at least 1), and the optional position defaults to end. Positioning options include start (or jump-start), which jumps immediately at the beginning of each interval; end (or jump-end), which holds until the end of each interval before jumping; and jump-none, which ensures jumps occur strictly within the open interval (0, 1) without aligning to boundaries. jump-both allows jumps at both endpoints for full coverage. This function is ideal for frame-by-frame animations, such as a segmented wheel rotating in fixed increments.[20][21]
These easing functions are applied via the animation-timing-function property, which can be set on individual keyframes or the overall animation declaration. Cubic-bezier curves were introduced in the CSS Animations specification to expand beyond basic linear interpolation, enabling more expressive timing control.[1]
Advanced Features
Animation States and Events
CSS animations can be controlled during runtime through the animation-play-state property, which allows developers to pause and resume animations dynamically without altering the underlying keyframes or timing definitions. The property accepts two primary values: running, which is the default state enabling the animation to proceed as defined, and paused, which halts the animation at its current progress, preserving the computed styles from the last frame. Toggling between these states can be achieved via CSS selectors such as hover effects—for instance, pausing an animation on :hover to create interactive feedback—or through media queries to adapt behavior based on device orientation or screen size, ensuring responsive control without JavaScript intervention.
In contrast to CSS transitions, which manage state changes between two discrete styles (e.g., from inactive to active) and inherently pause during their execution phase, CSS animations offer more granular state management over multi-step, keyframe-based sequences. Transitions are typically triggered by property changes and complete once the endpoint is reached, limiting their utility for indefinite or looping behaviors, whereas animations maintain persistent states that can be paused mid-cycle and resumed seamlessly, making them suitable for complex, ongoing visual effects like continuous rotations or breathing interfaces.
Dynamic state control can be enhanced by integrating CSS custom properties (variables) with animation-play-state, allowing real-time adjustments based on user interactions or environmental changes. For instance, a custom property like --anim-state: running; can be toggled via media queries or class additions, then referenced in the animation declaration as animation-play-state: var(--anim-state);, providing a modular approach to synchronize states across multiple elements or animations while maintaining separation of concerns in stylesheet design. This method leverages the cascading nature of CSS to propagate state changes efficiently, though it complements rather than replaces direction and fill modes for endpoint handling.
Integration with Other Technologies
CSS animations can be dynamically controlled using JavaScript, allowing developers to add or remove animation classes, modify properties at runtime, or respond to user interactions. For instance, the addEventListener method can be attached to elements to detect the animationend event, enabling scripts to chain animations or update the DOM upon completion. This approach is particularly useful for creating interactive experiences, such as pausing an animation based on user input or restarting it after a delay.
A key distinction exists between CSS animations and CSS transitions: animations support complex, multi-step sequences defined via @keyframes, making them suitable for intricate effects like rotating and scaling an element simultaneously, whereas transitions are limited to simple interpolations between two states, typically triggered by property changes like hover. This separation allows animations to handle non-linear or looped behaviors without relying on scripting, though transitions often suffice for basic state changes due to their simplicity and lower overhead.
The Web Animations API serves as a programmatic interface that bridges CSS animations with JavaScript, enabling finer control over timing, playback, and synchronization across elements. Through methods like getAnimations(), developers can retrieve and manipulate active animations on a document or element, such as pausing, reversing, or seeking to specific points in the timeline. This API unifies CSS-based and scripted animations, facilitating advanced scenarios like coordinating multiple animations in response to network events or user gestures.
An practical example of this integration involves triggering CSS animations on scroll using the Intersection Observer API, which monitors when an element enters the viewport and then applies an animation class via JavaScript. For code, an observer can be initialized with new IntersectionObserver(callback), where the callback adds a class like .animate to the target element when its intersection ratio exceeds a threshold, initiating a predefined @keyframes sequence for effects like fade-ins. This method enhances performance by deferring animations until needed, avoiding unnecessary computations on initial page load.
Use in Scalable Vector Graphics
CSS animations enhance Scalable Vector Graphics (SVG) by enabling dynamic effects on vector-based elements such as icons and illustrations, leveraging the same keyframe and property mechanisms as in HTML. The Synchronized Multimedia Integration Language (SMIL), which was the original SVG animation standard, has been deprecated in the SVG 2 specification due to maintenance challenges and poor interoperability, though it remains supported in major browsers including Chrome as of November 2025.[22] CSS provides a modern, standardized alternative that integrates seamlessly with web styling and is recommended for future-proofing. SMIL's deprecation in SVG 2 underscores CSS's role as the preferred method for animating SVG, offering better performance and compatibility across user agents.[23]
SVG elements respond to CSS animations through animatable properties, including transforms for scaling, rotating, and translating shapes. For instance, the transform property can rotate an SVG circle continuously using @keyframes, defining rotations from 0deg to 360deg over a specified duration. Similarly, path elements can be animated via the d attribute when paths share compatible structures (e.g., the same number and type of points), allowing smooth morphing between shapes like a square transitioning to a circle through CSS transitions on the d value, though full support is limited to certain browsers like Chromium-based ones.[24]
Stroke-based effects, such as line drawing animations, utilize properties like stroke-dasharray and stroke-dashoffset. By setting stroke-dasharray to the path's total length and animating stroke-dashoffset from the length to 0, an SVG path appears to draw itself progressively, ideal for icons or logos. Gradients in SVG, defined via <linearGradient> or <radialGradient>, can also be animated by targeting stop elements' stop-color or offset properties with CSS keyframes, creating shifting color transitions for visual depth in graphics.
A key limitation is that CSS animations apply to style properties rather than SVG presentation attributes directly; attributes like fill or stroke must be mapped to their CSS equivalents (e.g., fill: red; instead of fill="red") to enable animation, as presentation attributes do not inherit CSS's full animatability without this conversion. This ensures precise control but requires developers to prioritize CSS declarations for dynamic effects.[25]
Optimization and Best Practices
To optimize CSS animations for performance, developers should prioritize properties that leverage hardware acceleration, such as transform and opacity, which can be processed efficiently on the GPU without triggering costly reflows or repaints in the rendering pipeline.[6][4] Animating layout-triggering properties like width, height, top, or left forces the browser to recalculate the document's layout on every frame, leading to jank and reduced frame rates, whereas GPU-accelerated changes occur in the compositing stage, allowing smoother 60 FPS animations on capable devices.[6][4]
Reducing overdraw is another key practice, achieved by minimizing the creation of compositing layers, as excessive layers can increase memory usage and GPU load without proportional benefits.[6] The will-change property, such as will-change: transform, hints to the browser to prepare an element for animation by promoting it to a layer, but it should be applied sparingly and only to elements actively animating, as overuse can lead to unnecessary resource allocation and performance degradation.[6][4] For example, applying will-change during an animation and removing it afterward via JavaScript helps balance optimization without persistent overhead.
Accessibility considerations are essential in CSS animations to respect user preferences and avoid exacerbating conditions like vestibular disorders.[26] The @media (prefers-reduced-motion: reduce) query detects when users have enabled reduced motion settings in their operating system, allowing developers to disable or simplify animations accordingly.[26] A common implementation replaces motion-heavy effects with static or subtle alternatives, as shown in this example:
css
@keyframes pulse {
0%, 100% { transform: scale(1); }
50% { transform: scale(1.1); }
}
.element {
animation: pulse 2s ease-in-out infinite;
}
@media (prefers-reduced-motion: reduce) {
.element {
animation: none; /* Or a non-motion alternative like opacity fade */
}
}
@keyframes pulse {
0%, 100% { transform: scale(1); }
50% { transform: scale(1.1); }
}
.element {
animation: pulse 2s ease-in-out infinite;
}
@media (prefers-reduced-motion: reduce) {
.element {
animation: none; /* Or a non-motion alternative like opacity fade */
}
}
This approach ensures inclusive experiences without compromising core functionality.[26]
For profiling and debugging animation performance, tools like Chrome DevTools provide robust capabilities to identify bottlenecks.[27] The Performance panel records traces, revealing frame rate drops via the FPS meter (aiming for 60 FPS) and highlighting issues like forced reflows in the flame chart during "Animation Frame Fired" events.[27] Complementing this, the Animations panel captures running animations, allows scrubbing timelines to inspect keyframes, and enables live modifications to durations or delays for iterative optimization.[28] Using CPU throttling in these tools simulates real-world constraints, such as mobile devices, to ensure animations remain fluid across hardware.[27]
Development and Support
Historical Evolution
The development of CSS animations originated in the early 2000s as part of the broader CSS3 specification efforts, with the first working draft of the CSS Animations module published by the W3C on March 20, 2009.[29] This draft was influenced by the need for native web animation capabilities amid the declining dominance of Adobe Flash, which had previously handled complex animations via plugins, and by the declarative animation syntax in SVG's SMIL (Synchronized Multimedia Integration Language). The CSS approach aimed to integrate animations directly into stylesheets, reducing reliance on scripting or external technologies while leveraging hardware acceleration for smoother performance.
Vendor prefixes played a crucial role in early adoption, with WebKit browsers introducing -webkit- prefixed properties in early 2009, followed by widespread implementation across major browsers by 2011, including Mozilla's -moz- and Microsoft's -ms- variants. This experimental phase enabled developers to test and refine animations despite incomplete standardization, though it led to fragmented support. By 2013, as implementations stabilized, browsers began supporting unprefixed properties, marking a shift toward broader compatibility and reducing the need for prefixes in production code.[30]
The W3C formalized CSS Animations Module Level 1 as a Recommendation on March 2, 2023, after years of iterative drafts and candidate recommendations, providing a stable foundation for keyframe-based animations, timing functions, and iteration controls.[1] Module Level 2, still in development as of 2025 with its latest Working Draft published on October 28, 2025, extends these with features like the animation-composition property—introduced in the first working draft of Level 2 in March 2023 to handle layering of multiple animations on the same property through replace, add, or accumulate modes. The animation-composition property has wide browser support since 2023 (Chrome 112+, Firefox 115+, Safari 16+, Edge 112+).[31] Meanwhile, scroll-linked animations, enabling progress tied to user scrolling, emerged in a separate W3C module (Scroll-driven Animations) with its first working draft in 2022, reflecting ongoing evolution. As of November 2025, scroll-driven animations are supported in Chrome 115+, Safari 17.6+, and Edge 115+, but not yet enabled by default in Firefox.[32][33]
Standardization was significantly shaped by collaboration within the W3C's CSS Working Group, where browser vendors such as Apple, Google, and Mozilla contributed implementations and feedback to align on specifications. The WHATWG's focus on living standards indirectly supported this by emphasizing practical web compatibility, though primary momentum came from vendor-driven prototypes that informed W3C drafts.
Browser Compatibility
CSS animations enjoy broad browser support as of 2025, with full implementation in all major modern browsers and near-universal coverage among active users. According to CanIUse data, unprefixed support reaches 95.14% globally, reflecting widespread adoption since the feature's stabilization around 2015.[5]
The following table summarizes key browser support timelines:
| Browser | Support Details |
|---|
| Chrome | Full support from version 4 (September 2008); unprefixed from 43 (2015). |
| Firefox | Full support from version 5 (June 2011). |
| Safari | Partial support in versions 4–5 (2009–2010, lacking steps() timing); full from 5.1 (2010). |
| Edge | Full support from version 12 (July 2015). |
| Internet Explorer | No native support in versions 6–9; full from 10 (October 2011), with partial workarounds via JavaScript libraries for older versions. |