Be the first to share your thoughts and start the conversation.
Sometimes, an animation needs more than just smooth movement or a playful bounce.
It needs to stretch, overshoot, and snap back dramatically like a rubber band.
Imagine pulling a slingshot. You stretch it… and then let go. It flies forward a bit too far, then bounces back and forth before it stops.
That’s the feeling elastic easing creates. It simulates the behavior of a spring or rubber band.
When something moves with elastic easing, it overshoots the target dramatically and then snaps back with diminishing oscillations before finally settling. This creates a feeling of tension and release.
Similar to other easing you’ve learned so far, Elastic Easing is also available in three variations:
ease:"elastic.in"// stretches in, like it’s charging up
ease:"elastic.out"// stretches past the target, then settles
ease:"elastic.inOut"// elastic on both ends
Elastic easing:
Graph animation may not be that clear, so go ahead and test elastic easings on a circle.
Elastic easing:
But it’s not just that. You can completely customize how dramatic it feels:
ease:"elastic.out(1, 0.3)"
As you can see, elastic accepts two arguments,
Amplitude (1)
It decides how far it stretches.
The higher the value, the bigger the wilder the overshoot.
Period (0.3)
It decides how fast it oscillates.
The smaller the value, the quicker the snapping.
You can always keep experimenting to find the right feel for your animation.
The most fun and useful one is elastic.out. You’ll probably use it the most in real-world UI.
When to use?
It’s great for onboarding animations, gamified elements, or any attention-grabbing actions. Anything literally that you want to behave like a spring.
Challenge
Let’s say you're working on a dashboard for a creative learning platform. Your team wants data visualizations to feel more playful and hand-crafted, not like typical sterile charts.
Your challenge is to build a bar chart that:
Feels like it was drawn in a notebook
Animates with elastic feedback when the data loads
Makes the data feel alive and delightful
Try to see how it feels or whether you think it’s even the best case to use elastic easing here. See yourself.
Solution
00:00:00 Here's the solution for the Elastic Easing Challenge.
00:00:05 As you already read about it, Elasting Ease creates that bouncy, spring-like motion that overshoots and oscillates before settling into place.
00:00:15 It mimics the effect of pulling and releasing a rubber band, making animations feel dynamic and playful.
00:00:23 There are different variants like in, out, and in-out, which controls when that bounce occurs.
00:00:30 So here's a challenge.
You can use it where you want to impress. Or surprise. Or just to make someone smile :D
Onto the next one 🤘
00:00:31 In front of us, we have a chart of sorts.
00:00:34 Let's explore where is it coming from.
00:00:36 Right here within this index.html, you can see that the only thing we has is this repeat button, as well as a div with an ID of chart.
00:00:45 Then, if you head over into style.css, you'll be able to see that this one has a few more styles than usual, because I needed them to create this nice-looking
00:00:54 chart from scratch.
00:00:55 And then if we head into the Script.js, we'll see the starter code of this lesson.
00:01:00 All of the code right here has absolutely nothing to do with GSAP.
00:01:05 It is all about rendering and modifying the chart.
00:01:09 but right here is where the G-Sub animation will go.
00:01:12 So let's quickly go through it.
00:01:14 We're first selecting the Repeat button so we can later on attach some functionality to it, then we have some sample data for each day of the week.
00:01:22 For example, 80, 60, 100, 70, and so on.
00:01:27 You can think of these as really any kind of data points that we could work with.
00:01:31 After that, we are getting the reference to the chart container, and then we're calculating the layouts by getting their current height.
00:01:39 We set the bar width and the spacing and value of all of those points so we know what is the maximum value that exists.
00:01:46 And then, you're ready to start rendering the charts by creating a new bar, giving it a specific number of pixels.
00:01:53 Then we start creating the bars for the values by first deciding its width.
00:01:58 And after the width, we need to define its height, which is the actual value that we want to display.
00:02:03 So we're doing that here.
00:02:05 And then finally we attach a label to it and assemble those components by appending different children to them.
00:02:11 But now is a time that do we actually animate it.
00:02:14 Here we can first import gsap at the top, and then we use our good old gsp.to where we target each individual bar, and want to animate each one of those
00:02:30 bars by giving it a scale y of 1. If you do that, immediately, you'll start seeing those different bars pop up on the screen.
00:02:39 Let's increase the duration so they happen over a longer period of time, like one second, or maybe even two.
00:02:47 There we go.
00:02:48 So now they're nicely filling in.
00:02:49 And finally, we're going to use the elastic easing by saying Ease Elastic.out And then you can even pass some additional numbers such as 1, which is the
00:03:03 number of bounces, and then maybe we can do 1.25 for how far it overshoots, giving it a springy, natural effect.
00:03:12 like a bar bouncing in place.
00:03:14 So if I save this, you can now see that it jumps up a bit and then comes down.
00:03:18 If I increase the number of bounces to something like 10, You can see now that jumps out so much more.
00:03:24 And finally, we can play with a staggered delay right here.
00:03:28 Whenever you have an array of elements, well, that's a good place to introduce a Stagger.
00:03:35 I'll add a delay to each one of these elements of...
00:03:39 Well, you could just add like 0.1 second, or you can increase it to maybe like 5 seconds, and then all of them would start happening after 5 second because
00:03:52 they're all part of the same animation.
00:03:55 But...
00:03:56 If you take the index of the bar that we're currently trying to animate, because we are right here within a forEach loop.
00:04:04 If we take that index and then multiply it by like 0.5 seconds for starters, you'll see that after each 0,5 second, a new bar will appear.
00:04:14 But you never want to be too aggressive with the animations, making them take too much time.
00:04:19 So we can just drop it down to like 0.1. so now they nicely appear one after another.
00:04:24 And I've also added the click event listener to the repeat function, so it rerenders the chart.
00:04:29 Whenever you click it, you can see all of those bars just pop into place one more time, with this elastic effect.
00:04:36 This seemingly very simple animation will make your static chart feel dynamic and interactive because each bar will grow elastically,
00:04:45 guiding the user's attention.
00:04:47 And you could try out some other easings.
00:04:49 For example, bounce.out instead of elastic.
00:04:54 You can see this one is much more exaggerated and might not feel good for a professional application, but if you want to go crazy with it,
00:05:02 well, be my guest.
00:05:03 you can also use something a bit more regular like power2.
00:05:07 out, for example.
00:05:09 And you could see that here it's just a little bit natural.
00:05:12 but I really like the elasticity for the charts.
00:05:15 And if you take a look at any kind of popular charts libraries, you'll notice that they use a very similar type of easing.
00:05:22 The more you understand the behind the scenes of these animations, the more will start seeing them as you browse the web.
