Mouvement subtil
Le mouvement, c'est l'assaisonnement. L'utilisateur doit ressentir que le site est « fluide », jamais remarquer « une animation ». Sources : The Illusion of Life de Disney, Laws of UX de Jon Yablonski, userinterface.wiki de Raphael Salaja, Emil Kowalski (fréquence d'utilisation).
Règles strictes (à ne jamais enfreindre)
- Animer uniquement
transformetopacity(plusfilter/clip-pathavec parcimonie). Ne jamais animerwidth,height,top,left,margin,padding, la taillebox-shadowoufont-size. Besoin de changer une ombre ? Animer par fondu l'opacityd'un pseudo-élément. - Timing vif : animation de l'UI sous 300 ms. Pression 80–120 ms, survol 150 ms, entrée 200–300 ms, sortie ≈ 70 % de l'entrée. Seule une animation « hero » unique peut aller jusqu'à 500 ms.
- Petites distances. Translation de 2–16 px, échelle de 0.97–1.03, rotation ≤ 6°. Plus grand donne l'impression d'être « animé ».
- Ralentir au début et à la fin. Jamais de
linearsur le mouvement. Ease-out pour entrer, ease-in pour sortir. - Fréquence d'utilisation : plus c'est utilisé, moins ça anime. Navigation clavier, palettes de commandes, onglets utilisés 100 fois/jour, sélection dans une liste : instantané (0 ms) ou fondu ≤ 100 ms. Animer les moments rares, pas les répétés.
- Seuil de Doherty : répondre sous 100 ms, terminer sous 400 ms. Le feedback (état pressé, état en attente) commence sur la même image que l'entrée. Tout ce qui est plus lent que 400 ms affiche une progression.
prefers-reduced-motion: reducesupprime le mouvement. Les fondus d'opacité peuvent rester.- Effets de survol uniquement sous
@media (hover: hover). Le tactile génère sinon des survols « collants ». - CSS d'abord, pas de bibliothèque d'animation sauf si le projet en a déjà une. Pas de boucle JS quand le CSS peut le faire.
- Ne jamais retarder ni cacher le contenu. Les révélations ne doivent pas cacher le contenu si JS échoue, bloquer les clics ou animer l'élément LCP au chargement.
- Mise en scène : un mouvement focal à la fois. Max environ 5 points de mouvement par page ; jamais deux choses en compétition pour l'œil au même moment.
will-changeuniquement pendant l'animation (ou sur ≤ 3 éléments persistants).- Interruptible par défaut. Un état qui peut basculer en plein vol (survol, bascule, ouverture/fermeture, indicateur d'onglet) utilise
transition, qui se recentre depuis sa position actuelle.@keyframesseulement pour les moments uniques (secousse, sonnerie, envoi) qui redémarrent proprement. - Adapter la durée à la taille et à l'initiateur. Les petits éléments plus rapides que les grands (icône 100 ms, carte 250 ms, panneau 300 ms). Action initiée par l'utilisateur = immédiat ; action initiée par le système (notification, mise à jour en arrière-plan) peut prendre la fin lente.
- Pas de clignotement > 3 ×/s ; tout ce qui boucle > 5 s doit avoir un contrôle de pause (ou ne pas boucler).
Les principes, en règles d'UI
Choisissez ceux qui correspondent au point d'interaction ; jamais tous à la fois. Chacun correspond à un motif ci-dessous.
| # | Principe | En UI, cela signifie | Motif |
|---|---|---|---|
| 1 | Étirement & compression | Les choses se compressent à l'impact, s'étirent en mouvement : le poids | Pression, Bascule |
| 2 | Anticipation | Léger retrait avant un grand mouvement (envoi, soumission, déploiement) | Bouton Envoyer |
| 3 | Mise en scène | Diriger l'œil vers une chose : atténuer les voisins, un mouvement à la fois | Focus de carte |
| 4 | Pose à pose | Définir les états de début/fin ; laisser le navigateur faire l'interpolation | transition, pas du JS image par image |
| 5 | Suivi | Les parties se stabilisent après l'arrêt du corps (petit dépassement) | Notification, Badge |
| 6 | Ralentir au début et à la fin | Accélérer et décélérer, jamais à vitesse constante | Variables |
| 7 | Arcs | Les éléments en mouvement se déplacent sur des courbes, pas des lignes droites | Vol vers le panier |
| 8 | Action secondaire | Petite fioriture qui soutient l'action principale | Anneau de succès |
| 9 | Timing vif | La durée donne la sensation ; UI < 300 ms | Variables |
| 10 | Feedback exagéré | Pousser au-delà du réel pour que le moment frappe (erreurs, succès) | Secousse d'erreur |
| 11 | Dessin solide / 3D | Donner de la profondeur et du volume aux choses plates | Carte inclinée |
| 12 | Attrait | La somme de chaque détail, cohérent sur tout le site | Passe de vérification |
| Loi d'UX | Conséquence sur le mouvement | Motif |
|---|---|---|
| Loi de Fitts | Les cibles plus grandes et plus proches sont plus rapides à atteindre | Zones de clic |
| Zones de clic plus grandes | Zone cliquable ≥ 44×44 px, même si le visuel est plus petit | Zones de clic |
| Loi de Hick | Plus de choix = décisions plus lentes ; ne pas animer beaucoup d'options à la fois | Limite d'échelonnement |
| Loi de Miller | Regrouper le contenu (~7 éléments) ; révéler en groupes, pas un par un | Limite d'échelonnement |
| Seuil de Doherty | Feedback < 100 ms, total < 400 ms, sinon afficher une progression | État en attente |
| Loi de Postel | Accepter une entrée désordonnée, retourner une sortie propre ; animer doucement le nettoyage | Format d'entrée |
| Loi de Jakob | Utiliser un mouvement conventionnel (menus qui descendent du déclencheur, modales qui apparaissent en fondu + échelle depuis le centre) | Superposition |
| Fréquence d'utilisation | Fréquent = moins d'animation | Règle 5 |
Flux de travail
- Lire d'abord le site. Framework, approche CSS (Tailwind, modules CSS, brut), mouvement et variables existants. Les réutiliser.
- Classer chaque élément interactif par fréquence : rare (inscription, paiement, succès), occasionnel (cartes, sections, modales), fréquent (navigation, onglets, palettes, lignes de liste). Fréquent obtient ≤ 100 ms ou rien.
- Choisir ≤ 5 points d'interaction, classés par rapport sensation/coût :
- Boutons/liens : compression à la pression + zone de clic (principes 1, Fitts)
- Retour de formulaire : secousse d'erreur, anneau de succès, état en attente (10, 8, Doherty)
- Cartes : soulèvement au survol, inclinaison optionnelle (11)
- Sections : révélation au défilement, échelonnement par groupes (6, Miller)
- Superpositions/notifications : entrée/sortie avec suivi (5, Jakob)
- Ajouter les variables une fois, globalement.
- Appliquer les motifs uniquement aux points d'interaction choisis.
- Vérifier (dernière section). Pas terminé avant vérification.
- Rapporter : chaque point d'interaction avec fichier:ligne, le principe appliqué et comment le voir.
Variables (ajouter une fois, globalement)
:root {
--ease-out: cubic-bezier(.23, 1, .32, 1); /* entrée, survol */
--ease-in: cubic-bezier(.55, 0, 1, .45); /* sortie */
--ease-in-out: cubic-bezier(.65, 0, .35, 1); /* déplacement à l'écran */
--ease-settle: cubic-bezier(.34, 1.4, .64, 1); /* suivi : ~4 % de dépassement */
/* sensation de ressort, interruptible ; les navigateurs sans `linear()` utilisent `ease` */
--ease-spring: linear(0, .07 3%, .29 9%, .62 18%, .86 28%, 1.01 40%, 1.03 50%, 1.015 65%, 1);
--dur-press: 100ms;
--dur-fast: 150ms;
--dur-base: 250ms;
--dur-slow: 300ms;
--rise: 8px;
}
@media (prefers-reduced-motion: reduce) {
:root { --rise: 0px; }
*, *::before, *::after {
animation-duration: 1ms !important;
animation-iteration-count: 1 !important;
transition-duration: 1ms !important;
scroll-behavior: auto !important;
}
}
Projet Tailwind ? Mettez ces valeurs dans @theme / tailwind.config extend plutôt que dans un nouveau fichier CSS.
Motifs
Pression : compression (1) + zone de clic (Fitts)
.btn {
position: relative;
transition: transform var(--dur-fast) var(--ease-out), background-color var(--dur-fast) var(--ease-out);
}
@media (hover: hover) { .btn:hover { transform: translateY(-1px); } }
.btn:active { transform: scale(.97); transition-duration: var(--dur-press); }
/* Petits boutons d'icône : agrandir la zone de clic, pas le visuel */
.icon-btn { position: relative; }
.icon-btn::before { content: ""; position: absolute; inset: 50% auto auto 50%; width: 44px; height: 44px; translate: -50% -50%; }
Bascule : compression & étirement (1)
Le bouton s'étire pendant le déplacement, se stabilise à l'arrivée.
.switch .knob { transition: transform var(--dur-base) var(--ease-settle); }
.switch[aria-checked="true"] .knob { transform: translateX(20px); }
.switch:active .knob { transform: scaleX(1.2); transform-origin: left; }
.switch[aria-checked="true"]:active .knob { transform: translateX(20px) scaleX(1.2); transform-origin: right; }
Envoyer / soumettre : anticipation (2)
Uniquement sur les actions « d'engagement » rares. Reculer de 2 px, puis partir.
@keyframes send { 0% { transform: none } 30% { transform: translate(-2px, 2px) } 100% { transform: translate(24px, -24px); opacity: 0 } }
.send.is-sending svg { animation: send 280ms var(--ease-in-out) forwards; }
Focus de carte : mise en scène (3)
@media (hover: hover) {
.grid:has(.card:hover) .card:not(:hover) { opacity: .6; }
}
.grid .card { transition: opacity var(--dur-base) var(--ease-out); }
Utiliser uniquement sur des grilles denses où un choix compte. Ignorer sur le contenu que l'on lit.
Soulèvement de carte + inclinaison optionnelle : dessin solide (11)
.card { position: relative; transition: transform var(--dur-base) var(--ease-out); }
.card::after {
content: ""; position: absolute; inset: 0; border-radius: inherit; pointer-events: none;
box-shadow: 0 12px 32px -12px rgb(0 0 0 / .25);
opacity: 0; transition: opacity var(--dur-base) var(--ease-out);
}
@media (hover: hover) {
.card:hover { transform: translateY(-3px); }
.card:hover::after { opacity: 1; }
}
Inclinaison (uniquement pour les éléments de démonstration comme un produit, un prix ou une carte de crédit ; ≤ 6°, pointeur uniquement, limité par rAF) :
if (matchMedia('(hover: hover) and (prefers-reduced-motion: no-preference)').matches) {
for (const el of document.querySelectorAll('.tilt')) {
let raf = 0;
el.addEventListener('pointermove', (e) => {
cancelAnimationFrame(raf);
raf = requestAnimationFrame(() => {
const r = el.getBoundingClientRect(); // lecture une fois par image, pas par transition
const x = (e.clientX - r.left) / r.width - .5, y = (e.clientY - r.top) / r.height - .5;
el.style.transform = `perspective(800px) rotateX(${-y * 6}deg) rotateY(${x * 6}deg)`;
});
});
el.addEventListener('pointerleave', () => { cancelAnimationFrame(raf); el.style.transform = ''; });
}
}
Notification / badge : suivi (5)
.toast { transition: transform var(--dur-slow) var(--ease-settle), opacity var(--dur-fast) var(--ease-out); }
.toast[data-state="closed"] { transform: translateY(12px); opacity: 0; transition-timing-function: var(--ease-in); }
Dépassement uniquement sur les choses qui arrivent (notifications, badges, compteurs), jamais sur la mise en page ou les blocs de texte.
Vol vers le panier : arcs (7)
Séparer X et Y sur deux éléments imbriqués avec des easings différents ; le chemin se courbe.
.fly-x { transition: transform 300ms linear; }
.fly-y { transition: transform 300ms var(--ease-in); }
.flying .fly-x { transform: translateX(var(--dx)); }
.flying .fly-y { transform: translateY(var(--dy)) scale(.4); }
Définir --dx/--dy à partir d'une lecture getBoundingClientRect() avant d'ajouter .flying.
Anneau de succès : action secondaire (8)
.btn.is-success::after {
content: ""; position: absolute; inset: -4px; border-radius: inherit; border: 2px solid currentColor;
animation: ring 400ms var(--ease-out) forwards; pointer-events: none;
}
@keyframes ring { from { opacity: .6; transform: scale(.95) } to { opacity: 0; transform: scale(1.15) } }
Secousse d'erreur : feedback exagéré (10)
@keyframes shake { 20%,60% { transform: translateX(-4px) } 40%,80% { transform: translateX(4px) } }
.field[aria-invalid="true"] { animation: shake 280ms var(--ease-in-out); }
Re-déclencher en supprimant et réajoutant l'attribut. Toujours associer à un message textuel (accessibilité).
État en attente : seuil de Doherty
Feedback de pression immédiatement ; si l'action prend > 400 ms, afficher un spinner/une progression à l'intérieur du bouton (garder sa largeur fixe pour éviter le décalage de mise en page). Préférer l'UI optimiste : afficher le résultat, annuler en cas d'erreur.
Entrée désordonnée → sortie propre : loi de Postel
Formater au blur (numéros de téléphone, numéros de carte, dates), pas à chaque frappe. Fondu enchaîné de la valeur avec un changement d'opacité de 150 ms, aucun mouvement.
Révélation au défilement : ralentir début/fin (6) + regroupement (Miller, Hick)
Contenu visible par défaut ; caché uniquement si JS confirme pouvoir le révéler.
.js .reveal {
opacity: 0; transform: translateY(var(--rise));
transition: opacity var(--dur-slow) var(--ease-out), transform var(--dur-slow) var(--ease-out);
transition-delay: calc(min(var(--i, 0), 5) * 50ms);
}
.js .reveal.in { opacity: 1; transform: none; }
document.documentElement.classList.add('js');
const io = new IntersectionObserver((entries) => {
for (const e of entries) if (e.isIntersecting) { e.target.classList.add('in'); io.unobserve(e.target); }
}, { rootMargin: '0px 0px -10% 0px' });
document.querySelectorAll('.reveal').forEach((el) => io.observe(el));
- Échelonner avec
style="--i: n"; limité à 6 étapes (Miller). Les longues listes se révèlent en un seul groupe. - Révéler une fois. Ignorer tout ce qui est au-dessus de la ligne de flottaison.
- Frameworks : même CSS ; exécuter l'observateur dans un effet de montage, déconnecter au démontage.
Superpositions : loi de Jakob
Mouvement conventionnel uniquement : les listes déroulantes grandissent depuis leur déclencheur (transform-origin du côté du déclencheur), les modales apparaissent en fondu + échelle 0.98→1 depuis le centre, les panneaux glissent depuis leur bord. Natif d'abord : <dialog> / popover avec @starting-style.
dialog, [popover] {
opacity: 0; transform: translateY(4px) scale(.98);
transition: opacity var(--dur-fast) var(--ease-in), transform var(--dur-fast) var(--ease-in),
overlay var(--dur-fast) allow-discrete, display var(--dur-fast) allow-discrete;
}
dialog[open], [popover]:popover-open {
opacity: 1; transform: none;
transition-timing-function: var(--ease-out); transition-duration: var(--dur-base);
}
@starting-style {
dialog[open], [popover]:popover-open { opacity: 0; transform: translateY(4px) scale(.98); }
}
Palette de commandes / menu ouvert au clavier plusieurs fois par jour : la fréquence d'utilisation impose de sauter la transition.
Onglets : surface de dossier qui glisse (pas un soulignement d'accentuation)
Le signe distinctif de l'IA/modèle est le mince soulignement d'accentuation, pas le mouvement. Utiliser une forme physique familière (Jakob) et laisser cette forme se déplacer :
- Onglets dossier (recommandé) : la surface de l'onglet sélectionné fusionne avec le panneau et glisse vers l'onglet cliqué.
- Contrôle segmenté : pour 2–4 options ; le segment enfoncé glisse de la même façon.
Faire en sorte que les onglets aient la même largeur pour que la surface n'ait besoin que de translateX (pas de largeur ou scaleX, qui déforme le rayon et la bordure). Utiliser une transition ≤ 150 ms pour qu'elle reste interruptible. Le contenu change instantanément (fréquence d'utilisation).
.tabs { position: relative; display: flex; gap: 2px; border-bottom: 1px solid var(--line); }
.tabs [role=tab] { position: relative; z-index: 1; flex: 0 0 auto; /* largeur fixe ou min-content/max-content */ padding: 8px 16px; border: none; background: none; cursor: pointer; }
.tabs .tab-surface {
position: absolute; bottom: 0; left: 0; height: 2px; background: var(--accent);
transition: transform 150ms var(--ease-out);
/* géré en JS via `style.width` + `style.transform` sur la surface */
}
/* contenu : transition 0ms, display:block/none */
// Gestion de l'onglet : cliquer change data-state, la surface se déplace via transform et largeur calculées sur la cible
const tabSurface = document.querySelector('.tab-surface');
const tabs = document.querySelectorAll('[role=tab]');
function moveSurface(target) {
const r = target.getBoundingClientRect();
const parent = target.closest('.tabs').getBoundingClientRect();
tabSurface.style.width = r.width + 'px';
tabSurface.style.transform = `translateX(${r.left - parent.left}px)`;
}
tabs.forEach(t => t.addEventListener('click', (e) => moveSurface(e.currentTarget)));
Vérification
Avant de déclarer terminé, vérifier ceci :
- Toutes les animations utilisent uniquement
transform/opacity. Aucune exception visible ? (Ouvrir l'inspecteur, cocher « CSS transitions » dans l'onglet Animations, faire glisser le curseur). - La page chargée a la même disposition avec ou sans animation (
jsnon présent →.revealvisible). -
@media (prefers-reduced-motion: reduce): déplacer le curseur « Réduire le mouvement » dans les devtools → le mouvement s'arrête. Simuler avecemulate CSS media feature prefers-reduced-motion: reduce. -
@media (hover: hover): le survol fonctionne sur un écran avec souris ; un écran tactile ne montre pas de survol persistant après avoir tapé (utiliserchrome emulate touch/ responsive mode). - Pas de sauts de mise en page (regarder le score Cumulative Layout Shift dans Lighthouse).
- Les animations se déclenchent au premier survol/pression, pas après un délai (pas de
transition-delaynégatif, pas deanimation-delaysauf pour l'échelonnement). - Les transitions sont interruptibles : survoler rapidement différents onglets/cartes → l'élément s'adoucit vers la nouvelle cible, ne finit pas la première animation.
- Conservation de la tabulation au clavier : tous les éléments interactifs sont atteignables et activables au clavier (Tab, Entrée/Espace). Les animations ne verrouillent pas le focus.
- La révélation au défilement se produit une fois et n'est pas retardée par l'échelonnement du chargement asynchrone (vérifier avec un réseau lent /
Fast 3G). - Le rapport liste chaque point d'interaction avec fichier:ligne, le principe et comment le voir (par exemple « survoler la carte 4 dans la grille principale »).
## Rapport
<point d'interaction> | <principe # / loi> | fichier:ligne |
- Bouton .btn-primary | 1, Fitts | src/components/Button.css:12 | survoler ou cliquer le bouton « Envoyer »
- Champ .email | 10, Doherty | src/components/Form.css:34 | saisir une adresse invalide, tabuler hors du champ
- Carte .product-card | 11, 3 | src/components/Card.css:7 | survoler la carte « Montre »