Communitygithub.com

Motion Craft

Concevez des animations accélérées par GPU avec l'API Web Animations (WAAPI), les animations pilotées par le défilement (ScrollTimeline/ViewTimeline), la technique FLIP, les systèmes d'easing et l'accessibilité (prefers-reduced-motion).

Qu'est-ce que Motion Craft ?

Motion Craft est un guide et un ensemble de directives pour la création d'animations web performantes et accessibles. Il couvre les API modernes comme WAAPI, ScrollTimeline et ViewTimeline, ainsi que les techniques FLIP et les systèmes d'easing avancés. L'accent est mis sur l'accessibilité avec le support de `prefers-reduced-motion` et sur l'optimisation des performances en limitant les animations aux propriétés `transform` et `opacity`. Il est conçu pour être utilisé avec des agents IA (comme Claude Code, Cursor, Codex) afin de générer des animations UI réactives, fluides et respectueuses des bonnes pratiques, en évitant les animations non essentielles ou coûteuses.

Compatible avec~Claude Code~Codex CLI✓Cursor✓OpenCode
npx skills add https://github.com/EliasOulkadi/shokunin/tree/HEAD/.pack/skills/motion-craft

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

Documentation

Que fait Motion Craft ?

Des animations qui communiquent, pas qui décorent. Chaque image doit mériter sa place.

Inspiré par Emil Kowalski (Linear, Sonner, Vaul), Paul Lewis (Google Chrome) et le CSS Animation Working Group.

Workflow

Le Cadre de Décision des Animations

Avant d'écrire du code d'animation, répondez à ces quatre questions dans l'ordre.

1. Cette animation doit-elle exister ?

FréquenceDécisionRaison
100+ fois/jour (raccourcis clavier, palette de commandes, bascule de recherche)Pas d'animation. Jamais.L'animation rend les actions fréquentes lentes. Raycast n'a pas d'animation d'ouverture/fermeture. Optimal.
Des dizaines de fois/jour (effets de survol, navigation dans une liste)Supprimer ou réduire considérablementLes utilisateurs remarquent la latence des animations lors d'interactions répétées
Occasionnel (modales, tiroirs, toasts)Animation standardLe bon endroit pour le mouvement
Rare / première fois (onboarding, confirmation, célébration)Ajouter du plaisirCes moments méritent des animations plus longues et plus riches

Ne jamais animer les actions initiées par le clavier. Elles se répètent des centaines de fois par jour.

2. Quel est l'objectif ?

Chaque animation doit avoir une réponse claire à "pourquoi cela bouge ?"

ObjectifExempleValide ?
Cohérence spatialeLe toast entre et sort de la même direction?
Indication d'étatLe bouton se transforme pour montrer "envoyé"?
FeedbackLe bouton rétrécit lors de l'appui, confirmant que l'interface a entendu l'utilisateur?
Éviter les changements brusquesLes éléments apparaissent en fondu au lieu d'apparaître soudainement?
ExplicationAnimation marketing montrant comment une fonctionnalité fonctionne?
"C'est beau" ET l'utilisateur le voit souventMouvement gratuit?

3. Quel easing utiliser ?

ScénarioEasingCSS
Élément entrantease-out (commence vite, semble réactif)cubic-bezier(0, 0, 0.2, 1)
Élément sortantease-in (commence lentement, attire brièvement l'attention puis accélère)cubic-bezier(0.4, 0, 1, 1)
Mouvement / transformation à l'écranease-in-outcubic-bezier(0.4, 0, 0.2, 1)
Survol / changement de couleureasecubic-bezier(0.25, 0.1, 0.25, 1)
Mouvement constant (marquee, barre de progression)linearcubic-bezier(0, 0, 1, 1)
Interactions UI (boutons, infobulles, menus déroulants)strong ease-outcubic-bezier(0.23, 1, 0.32, 1)

Critique : ne jamais utiliser ease-in pour les animations d'entrée UI. Un menu déroulant avec ease-in à 300ms semble plus lent qu'avec ease-out à la même durée de 300ms car ease-in retarde le mouvement initial - le moment exact que l'utilisateur observe le plus attentivement.

4. Quelle devrait être la vitesse ?

ÉlémentDuréeEasing
Feedback de pression sur un bouton (échelle)100-160mscubic-bezier(0.23, 1, 0.32, 1)
Entrée / sortie d'infobulle125-200mscubic-bezier(0.23, 1, 0.32, 1)
Menu déroulant / select / popover150-250mscubic-bezier(0.23, 1, 0.32, 1)
Transformation au survol (échelle, élévation)200mscubic-bezier(0.23, 1, 0.32, 1)
Entrée de modale / boîte de dialogue200-300mscubic-bezier(0, 0, 0.2, 1)
Sortie de modale / boîte de dialogue150-200mscubic-bezier(0.4, 0, 1, 1)
Entrée de tiroir / panneau200-400mscubic-bezier(0.32, 0.72, 0, 1) (comme iOS)
Entrée de toast300-400mscubic-bezier(0.23, 1, 0.32, 1)
Sortie de toast200-300mscubic-bezier(0.4, 0, 1, 1)
Transition de page300-400mscubic-bezier(0.4, 0, 0.2, 1)
Révélation au défilement (fondu + glissement vers le haut)400-800mscubic-bezier(0.16, 1, 0.3, 1)
Shimmer de chargement1000-1500ms (infini)linear
Appui long pour supprimer (pression)2000mslinear (délibéré)
Appui long pour supprimer (relâchement)200mscubic-bezier(0.23, 1, 0.32, 1) (rapide)
Marketing / explicatif800-3000msvariable, dépend du récit

Règle : Les animations UI doivent rester sous 300ms. Un menu déroulant à 180ms semble nettement plus réactif qu'un à 400ms.

Courbes d'easing personnalisées

Les ease / ease-in / ease-out CSS intégrés sont trop faibles. Utilisez ces variantes personnalisées plus fortes :

:root {
  --ease-out-strong: cubic-bezier(0.23, 1, 0.32, 1);     /* Interactions UI, la signature d'Emil */
  --ease-in-out-strong: cubic-bezier(0.77, 0, 0.175, 1);  /* Mouvement à l'écran */
  --ease-drawer: cubic-bezier(0.32, 0.72, 0, 1);          /* Tiroir type iOS */
  --ease-out-expo: cubic-bezier(0.16, 1, 0.3, 1);         /* Révélations lentes, dramatiques */
  --ease-out-quint: cubic-bezier(0.22, 1, 0.36, 1);       /* Alternative forte ease-out */
  --ease-spring: cubic-bezier(0.34, 1.56, 0.64, 1);       /* Léger dépassement, avec parcimonie */
}

Sources : easing.dev, easings.co


La Règle d'Or du 60fps

16,67 ms par image. Vérifiez avec l'onglet Performance de Chrome DevTools. Animer uniquement transform et opacity.

PropriétéComposite GPU ?Déclencheurs
transform (translate, scale, rotate)? OuiComposite uniquement
opacity? OuiComposite uniquement
filter?? ParfoisPeinture + Composite
clip-path?? ParfoisPeinture + Composite
width, height, top, left, margin, padding, border-width? NonLayout + Peinture + Composite
box-shadow? NonPeinture + Composite
color, background-color? NonPeinture uniquement

Format de Révision (Obligatoire)

Lors de la révision du code d'animation UI, vous DEVEZ utiliser un tableau markdown avec les colonnes Avant | Après | Pourquoi. N'utilisez PAS de liste avec "Avant :" et "Après :" sur des lignes séparées.

Format correct :

AvantAprèsPourquoi
transition: all 300mstransition: transform 200ms ease-outSpécifiez les propriétés exactes ; évitez all qui déclenche le recalcul de la mise en page
transform: scale(0)transform: scale(0.95); opacity: 0Rien dans le monde réel n'apparaît de nulle part
ease-in sur le menu déroulantcubic-bezier(0.23, 1, 0.32, 1)ease-in commence lentement - semble lent. Un ease-out fort donne un retour instantané
Pas d'état :active sur le boutontransform: scale(0.97) sur :activeLes boutons doivent sembler réactifs à la pression
transform-origin: center sur le popovertransform-origin: var(--radix-popover-content-transform-origin)Les popovers doivent se déployer depuis leur déclencheur. Les modales restent centrées.
transition: 300ms sans prefers-reduced-motion@media (prefers-reduced-motion: reduce) { transition-duration: 0.01ms }WCAG 2.1 exige le support du mouvement réduit
animate={{ x: 100 }} dans Framer Motionanimate={{ transform: "translateX(100px)" }}Les propriétés x/y de Framer Motion NE sont PAS accélérées par le matériel. Utilisez la chaîne transform pour le GPU.

Format incorrect (à ne jamais faire) :

Avant : transition: all 300ms
Après : transition: transform 200ms ease-out

Transitions CSS (recommandées pour l'UI)

Les transitions CSS sont interruptibles - elles peuvent être redirigées en pleine animation. Les keyframes redémarrent de zéro. Pour toute interaction pouvant être déclenchée rapidement (toasts, toggles, menus déroulants), les transitions produisent des résultats plus fluides.

.button {
  transition: transform 160ms ease-out;
}
.button:active {
  transform: scale(0.97);
}

.tooltip {
  transition: transform 125ms ease-out, opacity 125ms ease-out;
  transform-origin: var(--transform-origin);
}

Timing asymétrique entrée / sortie

L'entrée peut être plus lente (l'utilisateur décide), la sortie doit être rapide (le système répond) :

.overlay {
  transition: clip-path 200ms ease-out;  /* relâchement: rapide */
}
.button:active .overlay {
  transition: clip-path 2s linear;       /* pression: lent et délibéré */
}

Infobulles : ignorer le délai lors des survols suivants

.tooltip {
  transition: transform 125ms ease-out, opacity 125ms ease-out;
  transform-origin: var(--transform-origin);
}
.tooltip[data-instant] {
  transition-duration: 0ms;
}

États d'entrée avec @starting-style (Chrome uniquement à partir de 2026, pas encore Baseline)

.toast {
  opacity: 1;
  transform: translateY(0);
  transition: opacity 400ms ease-out, transform 400ms ease-out;

  @starting-style {
    opacity: 0;
    transform: translateY(100%);
  }
}

Remarque : @starting-style et les animations pilotées par le défilement (animation-timeline: view(), animation-timeline: scroll()) sont réservées à Chrome à partir de 2026. Utilisez des solutions de repli JavaScript avec IntersectionObserver pour la compatibilité multi-navigateurs.

Motif d'appui long pour supprimer

.overlay {
  clip-path: inset(0 100% 0 0);
  transition: clip-path 200ms ease-out;   /* relâchement: rapide */
}
.button:active .overlay {
  clip-path: inset(0 0 0 0);
  transition: clip-path 2s linear;        /* pression: lent et délibéré */
}

BOUTONS - Feedback Tactile

Chaque élément pressable a besoin d'une réponse physique.

.button {
  transition: transform 160ms cubic-bezier(0.23, 1, 0.32, 1);
}
.button:active {
  transform: scale(0.97);
}

L'échelle doit être subtile (0,95-0,98). Appliqué à tous les éléments pressables - boutons, cartes, éléments de liste, onglets.


POPOVERS - Conscients de l'Origine

Les popovers se déploient depuis leur déclencheur, pas depuis le centre. Les modales restent centrées.

/* Radix UI */
.popover {
  transform-origin: var(--radix-popover-content-transform-origin);
}
/* Base UI */
.popover {
  transform-origin: var(--transform-origin);
}
/* Modales (toujours centrées) */
.modal {
  transform-origin: center;
}

Que l'utilisateur les remarque individuellement ou non n'a pas d'importance. Dans l'ensemble, les détails invisibles s'accumulent.


Animations Échelonnées

Lorsque plusieurs éléments entrent ensemble, échelonnez leur apparition.

.item {
  opacity: 0;
  transform: translateY(8px);
  animation: fadeIn 300ms ease-out forwards;
}
.item:nth-child(1) { animation-delay: 0ms; }
.item:nth-child(2) { animation-delay: 50ms; }
.item:nth-child(3) { animation-delay: 100ms; }
.item:nth-child(4) { animation-delay: 150ms; }

@keyframes fadeIn {
  to {
    opacity: 1;
    transform: translateY(0);
  }
}

Gardez les délais d'échelonnement courts (30-80 ms entre les éléments). Ne bloquez jamais l'interaction pendant que l'échelonnement se joue.


Animations CSS (keyframes)

Utilisez pour les animations prédéterminées et non dynamiques. Les keyframes redémarrent de zéro en cas d'interruption - à éviter pour l'UI.

@keyframes enter-right {
  from { opacity: 0; transform: translateX(16px); }
  to   { opacity: 1; transform: translateX(0); }
}
.enter {
  animation: enter-right 300ms ease-out forwards;
}

Animations à Ressort

Les ressorts semblent plus naturels que les animations basées sur la durée car ils simulent la physique réelle. Ils maintiennent la vélocité lorsqu'ils sont interrompus.

Quand utiliser les ressorts

  • Interactions de glissement avec élan
  • Éléments qui semblent "vivants" (style Apple Dynamic Island)
  • Gestes qui peuvent être interrompus en pleine animation
  • Interactions décoratives de suivi de souris

Approche Apple (recommandée - plus facile à raisonner)

{ type: "spring", duration: 0.5, bounce: 0.2 }

Physique traditionnelle (plus de contrôle)

{ type: "spring", stiffness: 100, damping: 10, mass: 1 }

Gardez le rebond subtil (0,1-0,3). Évitez le rebond dans la plupart des UI. Utilisez-le uniquement pour le rejet par glissement et les interactions ludiques.

Interactions souris basées sur ressort

import { useSpring } from 'framer-motion'

const springX = useSpring(mouseX * 0.1, { stiffness: 100, damping: 10 })

Sans ressort : semble artificiel, instantané. Avec ressort : semble naturel, a de l'élan.


API WEB ANIMATIONS (WAAPI)

Animations CSS programmatiques. Accélérées par le matériel, interruptibles, sans bibliothèque nécessaire.

const element = document.querySelector('.card')

const animation = element.animate([
  { transform: 'scale(1)', opacity: 1 },
  { transform: 'scale(0.95)', opacity: 0.7 },
], {
  duration: 200,
  easing: 'cubic-bezier(0.23, 1, 0.32, 1)',
  fill: 'both',
})

animation.pause()
animation.play()
animation.reverse()
animation.finish()
animation.finished.then(() => console.log('done'))

WAAPI bat Framer Motion sous charge élevée - elle s'exécute en dehors du thread principal. Utilisez-la pour les animations dynamiques et interruptibles là où les keyframes CSS sont insuffisants.


ANIMATIONS PILOTÉES PAR LE DÉFILEMENT

Remarque sur la compatibilité navigateur : Les animations pilotées par le défilement (animation-timeline: view() et scroll()) sont réservées à Chrome/Edge à partir de 2026, pas encore Baseline. Fournissez des solutions de repli JS via IntersectionObserver pour Firefox/Safari.

ViewTimeline (l'élément entre/sort du viewport)

@keyframes fade-up {
  from { opacity: 0; transform: translateY(20px); }
  to   { opacity: 1; transform: translateY(0); }
}
.reveal {
  animation: fade-up 600ms linear both;
  animation-timeline: view();
  animation-range: entry 0% entry 100%;
}

ScrollTimeline (position de défilement de la page)

@keyframes shrink {
  from { height: 80px; }
  to   { height: 50px; }
}
.site-header {
  animation: shrink 300ms linear both;
  animation-timeline: scroll();
  animation-range: 0 200px;
}

Parallaxe lié au défilement (JS vanilla)

const layers = document.querySelectorAll('[data-parallax]')
window.addEventListener('scroll', () => {
  const scrollY = window.scrollY
  layers.forEach(layer => {
    const speed = parseFloat(layer.dataset.parallax) || 0.3
    layer.style.transform = `translateY(${scrollY * speed}px)`
  })
})

Technique FLIP

Pour les animations de mise en page - animer des éléments qui changent de position/taille.

function animateLayout(element, callback) {
  const first = element.getBoundingClientRect()
  callback()
  const last = element.getBoundingClientRect()

  const dx = first.left - last.left
  const dy = first.top - last.top
  const dw = first.width / last.width
  const dh = first.height / last.height

  element.animate([
    { transform: `translate(${dx}px, ${dy}px) scale(${dw}, ${dh})` },
    { transform: 'translate(0, 0) scale(1, 1)' },
  ], {
    duration: 300,
    easing: 'cubic-bezier(0.4, 0, 0.2, 1)',
  })
}

CLIP-PATH pour l'Animation

L'un des outils d'animation les plus puissants en CSS. Accéléré par le matériel.

.overlay {
  clip-path: inset(0 100% 0 0);
  transition: clip-path 200ms ease-out;
}
.visible {
  clip-path: inset(0 0 0 0);
}

Utilisez pour : appui long pour supprimer, révélations d'image au défilement, curseurs de comparaison, transitions de couleur fluides sur les onglets.


PERFORMANCE PERÇUE

La vitesse dans l'animation affecte directement la façon dont...

Individual skills in this repo

This repo contains 2 individual skills — each has its own dedicated page.

Skills associés