Want to Contribute to us or want to have 15k+ Audience read your Article ? Or Just want to make a strong Backlink?

Responsive Animations for Every Screen Size and Device | Style-Tricks

Earlier than I profession jumped into improvement, I did a bunch of movement graphics work in After Results. However even with that background, I nonetheless discovered animating on the net fairly baffling.

Video graphics are designed inside a particular ratio after which exported out. Carried out! However there aren’t any “export settings” on the net. We simply push the code out into the world and our animations must adapt to no matter machine they land on.

So let’s discuss responsive animation! How will we greatest method animating on the wild wild net? We’re going to cowl some normal approaches, some GSAP-specific suggestions and a few movement rules. Let’s begin off with some framing…

How will this animation be used?

Zach Saucier’s article on responsive animation recommends taking a step again to consider the ultimate end result earlier than leaping into code.

Will the animation be a module that’s repeated throughout a number of elements of your utility? Does it have to scale in any respect? Preserving this in thoughts may also help decide the tactic during which an animation must be scaled and hold you from losing effort.

That is nice recommendation. A big a part of designing responsive animation is figuring out if and the way that animation must scale, after which selecting the best method from the beginning.

Most animations fall into the next classes:

  • Fastened: Animations for issues like icons or loaders that retain the identical dimension and side ratio throughout all units. Nothing to fret about right here! Laborious-code some pixel values in there and get on together with your day.
  • Fluid: Animations that have to adapt fluidly throughout totally different units. Most structure animations fall into this class.
  • Focused: Animations which are particular to a sure machine or display dimension, or change considerably at a sure breakpoint, akin to desktop-only animations or interactions that depend on device-specific interplay, like contact or hover.

Fluid and focused animations require alternative ways of pondering and options. Let’s have a look…

Fluid animation

As Andy Bell says: Be the browser’s mentor, not its micromanager — give the browser some strong guidelines and hints, then let it make the suitable choices for the those who go to it. (Listed below are the slides from that presentation.)

Fluid animation is all about letting the browser do the onerous work. Quite a lot of animations can simply regulate to totally different contexts simply through the use of the suitable items from the beginning. In case you resize this pen you possibly can see that the animation utilizing viewport units scales fluidly because the browser adjusts:

The purple field even modifications width at totally different breakpoints, however as we’re utilizing percentages to maneuver it, the animation scales together with it too.

Animating structure properties like left and prime may cause structure reflows and jittery ‘janky’ animation, so the place attainable keep on with transforms and opacity.

We’re not simply restricted to those items although — let’s check out another potentialities.

SVG items

One of many issues I like about working with SVG is that we will use SVG person items for animation that are responsive out of the field. The clue’s within the identify actually — Scalable Vector Graphic. In SVG-land, all parts are plotted at particular coordinates. SVG house is like an infinite little bit of graph paper the place we will organize parts. The viewBox defines the size of the graph paper we will see.

viewBox="0 0 100 50”

On this subsequent demo, our SVG viewBox is 100 items vast and 50 items tall. This implies if we animate the ingredient by 100 items alongside the x-axis, it’s going to all the time transfer by your entire width of its mother or father SVG, regardless of how massive or small that SVG is! Give the demo a resize to see.

Animating a toddler ingredient based mostly on a mother or father container’s width is somewhat tricker in HTML-land. Up till now, we’ve needed to seize the mother or father’s width with JavaScript, which is simple sufficient while you’re animating from a remodeled place, however somewhat fiddlier while you’re animating to someplace as you possibly can see within the following demo. In case your end-point is a remodeled place and also you resize the display, you’ll must manually regulate that place. Messy… 🤔

In case you do regulate values on resize, bear in mind to debounce, and even fireplace the operate after the browser is completed resizing. Resize listeners fireplace a ton of occasions each second, so updating properties on every occasion is numerous work for the browser.

However, this animation speed-bump is quickly going to be a factor of the previous! Drum roll please… 🥁

Container Items! Beautiful stuff. On the time I’m penning this, they solely work in Chrome and Safari — however possibly by the point you learn this, we’ll have Firefox too. Verify them out in motion on this subsequent demo. Take a look at these little lads go! Isn’t that thrilling, animation that’s relative to the mother or father parts!


Chrome Firefox IE Edge Safari
105 No No 105 16.0

Cellular / Pill

Android Chrome Android Firefox Android iOS Safari
106 No 106 16.0

Fluid structure transitions with FLIP

As we talked about earlier, in SVG-land each ingredient is neatly positioned on one grid and very easy to maneuver round responsively. Over in HTML-land it’s rather more advanced. In an effort to construct responsive layouts, we make use of a bunch of various positioning strategies and structure techniques. One of many principal difficulties of animating on the net is that quite a bit of modifications to structure are not possible to animate. Perhaps a component wants to maneuver from place relative to fastened, or some kids of a flex container have to be easily shuffled across the viewport. Perhaps a component even must be re-parented and moved to a completely new place within the DOM.

Tough, huh?

Nicely. The FLIP method is right here to save lots of the day; it permits us to simply animate these not possible issues. The fundamental premise is:

  • First: Seize the preliminary place of the weather concerned within the transition.
  • Final: Transfer the weather and seize the ultimate place.
  • Invert: Work out the modifications between the primary and final state and apply transforms to invert the weather again to their authentic place. This makes it seem like the weather are nonetheless within the first place however they’re truly not.
  • Play: Take away the inverted transforms and animate to their faked first state to the final state.

Right here’s a demo utilizing GSAP’s FLIP plugin which does all of the heavy lifting for you!

If you wish to perceive somewhat extra in regards to the vanilla implementation, head over to Paul Lewis’s blog post — he’s the mind behind the FLIP method.

Fluidly scaling SVG

You bought me… this isn’t actually an animation tip. However setting the stage appropriately is crucial for good animation! SVG scales tremendous properly by default, however we will management the way it scales even additional with preserveAspectRatio, which is mega helpful when the SVG ingredient’s side ratio and the viewBox side ratio are totally different. It really works a lot in the identical approach because the background-position and background-size properties in CSS. The declaration is made up of an alignment worth (background-position) and a Meet or Slice reference (background-size).

As for these Meet and Slice references — slice is like background dimension: cowl, and meet is like background-size: include.

  • preserveAspectRatio="MidYMax slice" — Align to the center of the x-axis, the underside of the y-axis, and scale as much as cowl your entire viewport.
  • preserveAspectRatio="MinYMin meet" — Align to the left of the x-axis, the highest of the y-axis, and scale up whereas protecting your entire viewBox seen.

Tom Miller takes this a step additional through the use of overflow: seen in CSS and a containing ingredient to disclose “stage left” and “stage proper” whereas protecting the peak restricted:

For responsive SVG animations, it may be helpful to utilize the SVG viewbox to create a view that crops and scales beneath a sure browser width, whereas additionally revealing extra of the SVG animation to the suitable and left when the browser is wider than that threshold. We are able to obtain this by including overflow seen on the SVG and teaming it up with a max-height wrapper to forestall the SVG from scaling an excessive amount of vertically.

Fluidly scaling canvas

Canvas is rather more performant for advanced animations with tons of transferring elements than animating SVG or HTML DOM, but it surely’s inherently extra advanced too. You must work for these efficiency positive aspects! In contrast to SVG that has pretty responsive items and scaling out of the field, <canvas> needs to be bossed round and micromanaged a bit.

I like organising my <canvas> in order that it really works a lot in the identical approach as SVG (I could also be biased) with a beautiful unit system to work inside and a hard and fast side ratio. <canvas> additionally must be redrawn each time one thing modifications, so bear in mind to delay the redraw till the browser is completed resizing, or debounce!

George Francis additionally put collectively this lovely little library which lets you outline a Canvas viewBox attribute and preserveAspectRatio — precisely like SVG!

Focused animation

Chances are you’ll typically have to take a much less fluid and extra directed method to your animation. Cellular units have quite a bit much less actual property, and fewer animation-juice performance-wise than a desktop machine. So it is sensible to serve lowered animation to cell customers, doubtlessly even no animation:

Generally the very best responsive animation for cell is not any animation in any respect! For cell UX, prioritize letting the person shortly devour content material versus ready for animations to complete. Cellular animations ought to improve content material, navigation, and interactions slightly than delay it. Eric van Holtz

In an effort to do that, we will make use of media queries to focus on particular viewport sizes identical to we do once we’re styling with CSS! Right here’s a easy demo displaying a CSS animation being dealt with utilizing media queries and a GSAP animation being dealt with with gsap.matchMedia():

The simplicity of this demo is hiding a bunch of magic! JavaScript animations require a bit extra setup and clean-up with a purpose to appropriately work at just one particular display dimension. I’ve seen horrors up to now the place individuals have simply hidden the animation from view in CSS with opacity: 0, however the animation’s nonetheless chugging away within the background utilizing up sources. 😱

If the display dimension doesn’t match anymore, the animation must be killed and launched for rubbish assortment, and the weather affected by the animation have to be cleared of any motion-introduced inline types with a purpose to forestall conflicts with different styling. Up till gsap.matchMedia(), this was a fiddly course of. We needed to hold monitor of every animation and handle all this manually.

gsap.matchMedia() as a substitute helps you to simply tuck your animation code right into a operate that solely executes when a specific media query matches. Then, when it now not matches, all of the GSAP animations and ScrollTriggers in that operate get reverted mechanically. The media question that the animations are popped into does all of the onerous be just right for you. It’s in GSAP 3.11.0 and it’s a recreation changer!

We aren’t simply constrained to display sizes both. There are a ton of media options on the market to hook into!

(prefers-reduced-motion) /* discover out if the person would favor much less animation */

(orientation: portrait) /* test the person's machine orientation */

(max-resolution: 300dpi) /* test the pixel density of the machine */

Within the following demo we’ve added a test for prefers-reduced-motion in order that any customers who discover animation disorienting gained’t be bothered by issues whizzing round.

And take a look at Tom Miller’s different enjoyable demo the place he’s utilizing the machine’s side ratio to regulate the animation:

Considering exterior of the field, past display sizes

There’s extra to fascinated about responsive animation than simply display sizes. Completely different units enable for various interactions, and it’s straightforward to get in a little bit of a tangle while you don’t contemplate that. In case you’re creating hover states in CSS, you should use the hover media function to check whether or not the person’s main enter mechanism can hover over parts.

@media (hover: hover) {
 /* CSS hover state right here */

Some recommendation from Jake Whitely:

Quite a lot of the time we base our animations on browser width, making the naive assumption that desktop customers need hover states. I’ve personally had numerous points up to now the place I might change to desktop structure >1024px, however would possibly do contact detection in JS – resulting in a mismatch the place the structure was for desktops, however the JS was for mobiles. Nowadays I lean on hover and pointer to make sure parity and deal with ipad Professionals or home windows surfaces (which may change the pointer kind relying on whether or not the duvet is down or not)

/* any contact machine: */
(hover: none) and (pointer: coarse)
/* iPad Professional */
(hover: none) and (pointer: coarse) and (min-width: 1024px)

I’ll then marry up my CSS structure queries and my JavaScript queries so I’m contemplating the enter machine as the first issue supported by width, slightly than the other.

ScrollTrigger suggestions

In case you’re utilizing GSAP’s ScrollTrigger plugin, there’s a helpful little utility you possibly can hook into to simply discern the contact capabilities of the machine: ScrollTrigger.isTouch.

  • 0no contact (pointer/mouse solely)
  • 1touch-only machine (like a telephone)
  • 2 – machine can settle for contact enter and mouse/pointer (like Home windows tablets)
if (ScrollTrigger.isTouch) {
  // any touch-capable machine...

// or get extra particular: 
if (ScrollTrigger.isTouch === 1) {
  // touch-only machine

One other tip for responsive scroll-triggered animation…

The next demo beneath is transferring a picture gallery horizontally, however the width modifications relying on display dimension. In case you resize the display while you’re midway by a scrubbed animation, you possibly can find yourself with damaged animations and off values. This can be a frequent speedbump, however one which’s simply solved! Pop the calculation that’s depending on display dimension right into a practical worth and set invalidateOnRefresh:true. That approach, ScrollTrigger will re-calculate that worth for you when the browser resizes.

Bonus GSAP nerd tip!

On cell units, the browser deal with bar often reveals and hides as you scroll. This counts as a resize occasion and can fireplace off a ScrollTrigger.refresh(). This won’t be supreme as it may trigger jumps in your animation. GSAP 3.10 added ignoreMobileResize. It doesn’t have an effect on how the browser bar behaves, but it surely prevents ScrollTrigger.refresh() from firing for small vertical resizes on touch-only units.

  ignoreMobileResize: true

Movement rules

I believed I’d depart you with some greatest practices to contemplate when working with movement on the net.

Distance and easing

A small however necessary factor that’s straightforward to overlook with responsive animation is the connection between velocity, momentum, and distance! Good animation ought to mimic the true world to really feel plausible, and it takes an extended in the true world to cowl a bigger distance. Take note of the gap your animation is touring, and be sure that the period and easing used is sensible in context with different animations.

You may also usually apply extra dramatic easing to parts with additional to journey to indicate the elevated momentum:

For sure use instances it could be useful to regulate the period extra dynamically based mostly on display width. On this subsequent demo we’re making use of gsap.utils to clamp the worth we get again from the present window.innerWidth into an affordable vary, then we’re mapping that quantity to a period.

Spacing and amount

One other factor to remember is the spacing and amount of parts at totally different display sizes. Quoting Steven Shaw:

If in case you have some sort of environmental animation (parallax, clouds, timber, confetti, decorations, and so on) which are spaced across the window, be sure that they scale and/or regulate the amount relying on display dimension. Giant screens most likely want extra parts unfold all through, whereas small screens solely want a number of for a similar impact.

I like how Opher Vishnia thinks about animation as a stage. Including and eradicating parts doesn’t simply must be a formality, it may be a part of the general choreography.

When designing responsive animations, the problem shouldn’t be the best way to cram the identical content material into the viewport in order that it “matches”, however slightly the best way to curate the set of present content material so it communicates the identical intention. Meaning making a aware alternative of which items content material so as to add, and which to take away. Normally on the planet of animation issues don’t simply pop in or out of the body. It is sensible to think about parts as coming into or exiting the “stage”, animating that transition in a approach that makes visible and thematic sense.

And that’s the lot. If in case you have any extra responsive animation suggestions, pop them within the remark part. If there’s something tremendous useful, I’ll add them to this compendium of knowledge!


Yet another be aware from Tom Miller as I used to be prepping this text:

I’m most likely too late with this tip to your responsive animations article, however I extremely suggest “finalize all of the animations earlier than constructing”. I’m at the moment retrofitting some web site animations with “cell variations”. Thank goodness for gsap.matchMedia… however I certain want we’d identified there’d be separate cell layouts/animations from the start.

I believe all of us recognize that this tip to “plan forward” got here on the absolute final minute. Thanks, Tom, and better of luck with these retrofits.

Add a Comment

Your email address will not be published. Required fields are marked *

Want to Contribute to us or want to have 15k+ Audience read your Article ? Or Just want to make a strong Backlink?