Motion Design Animation Basics

10 Principles of Motion Design That Will Elevate Your Animations Want to create animations that feel alive, professional, and impossible to ignore? Whether you’re a designer, marketer, or content creator, mastering these core principles will transform your motion work: 1️⃣ Timing, Spacing & Rhythm: The right pacing moves feel realistic and engaging. 2️⃣ Eases: Smooth in, smooth out. Avoid harsh linear motion for a more organic feel. 3️⃣ Mass & Weight: Objects have physics! Make movements reflect their size & mass. 4️⃣ Anticipation: Prepare the user’s eye for upcoming action with subtle hints. 5️⃣ Arcs: Natural movement follows curved paths, not straight lines. 6️⃣ Squash, Stretch & Smears: Add life and energy to motion while maintaining realism. 7️⃣ Follow Through & Overlapping Action: Things don’t stop abruptly; let them settle naturally. 8️⃣ Exaggeration: Push motion slightly beyond realism to make it more expressive. 9️⃣ Secondary or Layered Animation: Small details (like a bounce or shake) enhance primary motion. 🔟 Appeal: Motion should be aesthetically pleasing and reinforce the design’s purpose. Great motion design isn’t just about fancy tools—it’s about understanding the language of movement. These principles (rooted in Disney’s 12 animation basics!) are your cheat code for creating work that resonates. Which principle do you use most often? Or did I miss one you swear by? Drop your thoughts below! Sharing this with a designer who needs it? Tag them → let’s spread the knowledge! #MotionDesign #AnimationTips #DesignPrinciples #CreativeProcess #2danimation #AnimationPrinciples #AnimationBasics #LearnAnimation #AnimationForBeginners

💡How to design animated transitions Transition animations are key in product design because they guide users from one state to another. Meaningful transitions  ✔ Add animations only if they add meaning to interactions. Any movement, scaling, or motion in your product inherently suggests a direction. ✔ Animations should not distract from important tasks or information. Duration and speed of transition   ✔ Duration of the animation should be slow enough to give users the possibility to notice the change, but at the same time, quick enough not to cause waiting. ✔ Optimal speed for interface animation is between 100 and 500 ms. Transitions that are too slow (>500ms) can bore users, while overly fast transitions (<100ms) will be perceived as instantaneous and won’t be recognized at all. ✔ Duration of transition differs depending on the size of the object and distance. ✔ On mobile devices, Material Design suggests limiting the duration of animation to 200–300 ms.  ✔ For tablets, the duration should be longer by 30% — around 400–450 ms. The size of the screen is bigger, so objects travel longer distances when they change position. Easing curves  ✔ Easing helps to make the movement of the object more natural. For the animation not to look mechanical and artificial, the object should move with acceleration or deceleration. ✔ Ease-in makes animations start slowly and then accelerate towards the end, creating a sensation of gradually picking up speed. This curve should be used when the objects fly out of the screen at full speed. ✔ Ease-out starts animations at a quicker pace and slows down at the end, mimicking the natural deceleration of physical objects. This type of curve should be used when the element emerges on the screen. ✔ Ease-in-out is great for creating realistic movements. This curve makes the objects gain speed at the beginning and then slowly drop back to zero. Choreography ✔ When transitioning multiple elements, rank them by importance to help users focus on key interactions. Instead of transitioning all at once, sequence them by priority. ✔ Group similar items together, then rank these groups. Irrelevant groups can be hidden during the transition to maintain focus on crucial groups. Accessibility ✔ Provide an option to reduce motion effects for users sensitive to motion. ✔ Reduced motion doesn’t not mean mean no motion at all. ✔ Optimize animation for devices with a low refresh rate. 📖 Guides: ✔ The guide to proper use of animation in UI (by Taras Skytskyi)  https://lnkd.in/d4y4b7ds ✔ Transition animations: a practical guide (by Dongkyu Lee)  https://lnkd.in/diYNSFAR ✔ UX Motion + effective duration calculator (by Brainly) https://lnkd.in/eVH8dehQ ✔ Reduced motion for accessibility (by Eric Bailey)  https://lnkd.in/eH3y_Wnb #ui #animations

Today I want to share some behind the scenes work on how I go from idea to finished page transition. For this one, I wanted a wave of pixels moving across the screen without fully covering it, so both pages stay visible with a pixel wave as the separator. These are the challenges I solved: 1. My first step was stacking both pages and hiding one with a clip-path animation. I used the GSAP steps(12) function to create a stop motion feel linked to the number of pixels per row instead of a smooth transition. 2. Creating 100+ pixel elements by hand was not an option, so I built a helper that duplicates [data-transition-col] and [data-transition-pixel] based on a variable, in my example 12. It calculates how many pixels are needed to fill the screen. Before every transition run it checks the screen size so no resize listener is needed. 3. I started with a simple function animating pixels to opacity 1 randomly and back to 0. This is common, but I wanted to push it into a real wave effect. 4. The hardest part was syncing the clip-path steps with pixels fading randomly from 0 to 1. After lots of iteration I got a version that follows the clip-path edge perfectly. Keeping one line filled hides the page edge. 5. GSAP offers many stagger options. Random does exactly what you expect. Start/end controls direction, in my case per column top to bottom. I also tested center and edges for triangle shapes. Cool, but not the look I wanted. 6. After hours of tweaking and experimenting I nailed the timings, extra pixels, and the key behavior: pixels start first, then the clip-path begins when the wave reaches the edge, pauses, and lets some pixels continue. Everything is controlled with a few tweakable values: const pixelHorizontalAmount = 12; const transitionDuration = 1; const pixelFadeDuration = 0.2; const pixelOverlap = 0.3; Now you are going to ask: what are the last two doing? Pixel Fade Duration: controls how long a column fills. Increasing it makes the spacing feel larger. Pixel Overlap: controls how much pixels fade together, creating softer layered transparency instead of hard flashes. 7. Improving it for portrait devices Portrait screens felt too busy with 12 columns, so instead of complex breakpoints the animation switches direction automatically from left to right to top to bottom. Same values, cleaner result. Time insights 🕓 • 4 hours for the helper function and clip-path • 4 hours tweaking the animation • 2 hours to create this post and video Boilerplate ✨ I used the Osmo Supply boilerplate for the page transition setup. We also have a full Barba.js course showing how to build a One Page Application style site where current and next pages stay visible for transitions like this. This template will be available on Osmo Supply next Monday, so stay tuned. And that’s it! 👋 Hopefully you enjoyed a breakdown like this. If you did, please give this post a like so maybe I make another breakdown!

Make elements follow any path. No JavaScript or GSAP required. CSS motion paths let you animate an element along a curve, a loop, or any custom shape. You only need three properties. offset-path defines the route. You can use a path() from an inline SVG, or a simple shape. offset-distance moves the element along that route from 0% to 100%. offset-rotate: auto keeps the element aligned with the curve. A basic @keyframes animation changes the distance, and the element travels smoothly from start to finish. If you pair the CSS with an inline SVG, the SVG becomes a visual guide for the trajectory. It can stay visible, or remain hidden behind the animation. This technique is perfect for small UI details. Icons following a route. Loaders with interesting curves. Timelines. Diagrams. Interactive flourishes that feel alive without a single script. Browser support is strong at around 93 percent. And once you try motion paths, you will not want to animate with left or top again. Have you tested it yet? I would love to see the animations you create with it. To learn more tips about CSS, make sure to join my newsletter https://lnkd.in/eemgxQ7M ❤️

Good motion is so important! See the difference? It's subtle, but this is what separates the good from the okay. 🤓⚠️ Nerd talk alert, here's how I usually go about this: v1. First, I put the keyframes into place and roughly determine the timing. (It's a good idea to do this first for the whole video if you can. That way you'll never have to throw away a lot of work when feedback comes and things end up different, and for me it's also by far the fastest way of working). v2. Then, I easy-ease the keyframes and tweak the interpolation using Flow (an Ae script) until I can breathe again. I usually end up with a stronger ease-out than ease-in when doing transitioning animation. If there are several properties involved, I copy-paste the interpolation. v3. For animations that need more character, I tend to turn to Ae's graph editor and really finetune the curves, add some more keyframes, offset some of them, separate dimensions... This can take minutes to sometimes hours. The result is subtle, but this can really add character, convey feelings and make things really stand out ✨

▣ STACK PATTERNS ▣ Episode 11: The Page Transition You Never Had to Build "We need an SPA because users expect smooth transitions between pages." One has heard this argument rather a lot. It justified React. It justified Framer Motion. It justified Barba.js. It justified 400KB of JavaScript so that a heading could fade whilst the URL changed. The browser does it now. In CSS. Three lines. ■ THE PATTERN Both pages include this: @view-transition {  navigation: auto; } That is it. Click a link. The browser cross-fades between the old page and the new one. No JavaScript. No framework. No hydration. No virtual DOM diffing the entire document so that a title can slide. Want a specific element to animate from its old position to its new one? One line: h1 { view-transition-name: heading; } Same name on both pages. The browser snapshots the old position, snapshots the new position, and animates between them. The element does not need to be the same DOM node. It does not need to be the same component. It merely needs the same name. ■ THE COST WE PAID Let us be honest about what the industry traded for smooth page transitions. We abandoned server-rendered HTML. We shipped 300KB JavaScript runtimes. We broke the back button. We reinvented routing in userland. We lost native browser caching. We invented hydration to fix the problem we created by removing HTML. We built entire state management libraries so the client could remember what the server already knew. All so a heading could slide. ■ WHY IT WORKS The browser already knows when a navigation happens. It already paints both pages. The View Transition API simply tells it: screenshot the old state, screenshot the new state, animate. No framework needed because no framework was ever the right layer for this. Custom animations? CSS pseudo-elements: ::view-transition-old(heading) {  animation: slide-out 0.3s ease; } ::view-transition-new(heading) {  animation: slide-in 0.3s ease; } The old state and the new state are separate snapshots. You animate them independently. The browser handles the rest. ■ WHEN TO USE Multi-page applications that want native-feeling transitions. Blogs. Documentation sites. E-commerce product pages. Marketing sites. Every project where someone once said "we need React for the transitions" and was, regrettably, taken seriously. Chrome 126+. Edge 126+. Safari 18.2+. Firefox: partial (cross-document still behind a flag). Global coverage: 87.82% (CanIUse, April 2026). Not universal yet. And here is why that does not matter: unsupported browsers see a normal page load. No error. No fallback code. No polyfill. The feature costs nothing when absent and delights when present. That is progressive enhancement done properly. One does wonder what the SPA argument is now. Code in the first comment. #StackPatterns #CSS #ViewTransitions #WebDev #Frontend

Easing & Duration in UX Motion Design Have you ever noticed how nothing stops or starts on a dime in the real world? It's all about the graceful dance of acceleration and deceleration. That's exactly what our digital experiences should mimic to feel natural and engaging. Here's a quick guide to getting it just right within UX Motion Design: ✦ The Role of Easing: Think of easing as your animation's personality. Without it, movements are robotic. With it, they embody grace and realism. It's what makes your design breathe and resonate with users. ✦ Duration Decoded: Timing is vital. Too fast, and your users miss the action. Too slow, and they're yawning. Aim for the Goldilocks zone where every transition feels just right. ✦ Sensible Defaults to the Rescue: Need help figuring out where to start? Begin with some tried-and-true settings. They're like your reliable old friends who never let you down. Perfect for most scenarios, they'll give you a solid foundation to build upon and tweak as needed. ( https://easings.net is the perfect cheat sheet for communicating default easy-to-achieve easing types in CSS) In the example below from the GM3 easing guidelines ( https://lnkd.in/gyiQSUhg ), you see a transition with (blue) and without easing (red) with the same timing applied (meaning go from A to B over the same amount of time) Mixing easing with the suitable duration isn't just about aesthetics; it's about crafting an intuitive and immersive experience that feels as natural as the world around us. So, let's not just animate. Let's animate with intention, empathy, and a touch of magic. ✨ What are your go-to strategies for nailing the perfect easing and duration? Please share your thoughts, and let's inspire each other! #ux #uxdesign #motiondesign #animation #easing

Animating display CSS property with transition-behavior Discrete properties like display and overlay can’t be animated the traditional way because they have no intermediate values. For example, there’s no intermediate state between none and block, so unlike opacity (which smoothly transitions from 0 to 1), browsers couldn't interpolate display between none and block. Thanks to transition-behavior, now supported by major browsers, we can finally animate discrete properties like display and overlay. 🟦 allow-discrete transition-behavior: allow-discrete allows us to animate discrete properties which weren’t transitionable before. transition-behavior can be added as the last value in the transition shorthand declaration. transition: display 0.3s ease-out allow-discrete; Alternatively, we can define transition-behavior separately.. transition: display 0.3s ease-out, overlay 0.3s ease-out; transition-behavior: allow-discrete; When used separately, always place transition-behavior after the transition shorthand. 🟦 Entry and Exit animation A practical use case for allow-discrete is the native <dialog> element. When hidden, <dialog> uses display: none, and when shown, it's set to display: block. This makes it great for demonstrating how to animate discrete properties. 🔸 For the exit animation (fade-out), adding allow-discrete to the display transition enables a smooth disappearance. 🔸 For the entry animation (fade-in), we can use opacity along with @starting-style, which allows the animation to start from an initial visual state before the element becomes visible. And here is the code example. dialog { transition-property: opacity, display, overlay; transition-duration: 0.3s; transition-timing-function: ease-out; transition-behavior: allow-discrete; opacity: 0; } dialog[open] { opacity: 1; @starting-style { opacity: 0; } } This setup with transition-behavior: allow-discrete; gives us smooth entry and exit transitions using pure CSS with no JavaScript hacks needed. #frontend #css #displaytransition #dialog

Runway Gen-3 Alpha Middle Keyframes: Easy transitions Runway announced a new middle keyframe feature in Gen-3 that lets you easily transition between frames. You can use it for a consistent character and setting, or seamlessly change to similar scenes. I experimented with using 3 images with different scenes and similar styles for each clip, then combined for a quick holiday video. You don't have to use a text prompt, but it helps to describe what you want to see and how the model should transition between each frame. 🔹 Example video prompt: "Cinematic extreme close-up of an elegantly decorated Christmas tree in a modern, tech-influenced home. Beautifully wrapped gifts are nearby. Warm light trails enhance the image's sophisticated aesthetic. Focus is on the tree's refined details. hazy soft light, shallow depth of field, smooth camera movement, natural transitions between each frame, reflective surfaces, dynamic lighting, shot in 8k resolution" I was surprised at the smooth transition between frames, compared to previous results from using beginning and ending keyframes. This gives us more options for storytelling with seamless transitions. Have you tried it yet? If so, how do you use it for your videos? 🔹 Images: Midjourney 🔹 Audio: Epidemic Sound