Comment animer du SVG, et pourquoi le préférer à un GIF ?

Les animations SVG restent nettes à toutes les tailles et ne pèsent que quelques kilo-octets. Le tracé progressif anime stroke-dashoffset face à stroke-dasharray, les remplissages et les couleurs utilisent des transitions CSS, les formes se transforment entre des tracés qui ont le même nombre de points, et l'art génératif comme les champs de flux est calculé en JavaScript puis dessiné en SVG ou en canvas.

Comment choisir, performances et accessibilité
  • Utilisez Line Draw ou Logo Draw pour révéler un logo ou une illustration, Animated Icons pour les retours d'interface, et Perlin Flow Field ou Geometric Tessellation comme fonds génératifs.
  • Par rapport à un GIF, le SVG est plus léger, redimensionnable sans perte et modifiable en CSS.
  • Simplifiez les tracés complexes, donnez un title aux graphiques qui portent du sens et masquez les purement décoratifs aux lecteurs d'écran avec aria-hidden.
  • Line Draw, Perlin Flow Field et Text Mask Video sont gratuits avec leur code complet ; les autres sont inclus dans Premium.
Générateur

Vos SVG, en volume

Les effets ci-dessous animent vos SVG à plat. Le générateur SVG en 3D leur donne une épaisseur : vous déposez votre fichier, vous réglez la matière et les arêtes, et l'objet tourne. Un logo en PNG fait l'affaire, il est tracé au passage.

L'aperçu et l'image sont gratuits. Le code s'emporte pour 4,90 € (ce générateur, exports illimités) ou avec l'accès à vie.

Ouvrir le générateur

Line Draw

Chemin SVG qui se dessine progressivement avec stroke-dasharray et dashoffset.

CSS stroke-dasharray
Page de l’effet →
Voir le code source
HTML
<div class="fx-0599-root">
  <svg class="lnd-svg" viewBox="0 0 150 150" aria-hidden="true">
    <path class="lnd-path" pathLength="100" d="M20,75 L50,30 L80,60 L110,20 L130,50 M20,130 L60,90 L100,110 L130,80"/>
  </svg>
</div>
CSS
.fx-0599-root,.fx-0599-root *,.fx-0599-root *::before,.fx-0599-root *::after{box-sizing:border-box}
.fx-0599-root{--lnd-color:#6366f1;--lnd-stroke:3;--lnd-size:150px;--lnd-speed:3s;--lnd-repeat:infinite;--lnd-bg:rgb(26,26,36);--lnd-height:250px;display:flex;align-items:center;justify-content:center;width:100%;position:relative;color:#fff;font-family:sans-serif;height:var(--lnd-height);overflow:hidden;background:var(--lnd-bg)}
.fx-0599-root .lnd-svg{display:block;width:var(--lnd-size);max-width:100%;height:auto}
.fx-0599-root .lnd-path{fill:none;stroke:var(--lnd-color);stroke-width:var(--lnd-stroke);stroke-linecap:round;stroke-linejoin:round;stroke-dasharray:100;stroke-dashoffset:0;animation:lndDraw var(--lnd-speed) ease var(--lnd-repeat) both}
@keyframes lndDraw{0%{stroke-dashoffset:100}45%,55%{stroke-dashoffset:0}to{stroke-dashoffset:-100}}
@media (prefers-reduced-motion:reduce){.fx-0599-root .lnd-path{animation:none}}
JavaScript
/* CSS pur — aucun JavaScript requis */

Logo Draw

Logo en trois éléments qui se dessinent l'un après l'autre.

CSS Multi-layer

Morphing Shape

Forme qui passe du losange au cercle, à l'étoile puis au carré.

SMIL Morphing

SVG Fill Animation

Bouteille qui se remplit jusqu'à un niveau réglable puis se vide, en boucle.

CSS Clip-path

Animated Icons

Coche et croix qui se dessinent au trait dans leur cercle.

CSS Icons

Path Following

Élément qui suit un chemin SVG défini avec animateMotion.

SMIL animateMotion

SVG Text Draw

Texte dont le contour se dessine puis se remplit de couleur.

CSS Text

Pulse / Heartbeat

Cœur SVG avec animation de battement et ondes de pulsation.

CSS Pulse

Rotating Gears

Engrenages imbriqués qui tournent en sens inverse.

CSS Rotation

Wave Path

Ligne ondulante animée avec gradient et effet de mouvement.

SMIL Wave

Perlin Flow Field

Particules guidées par un champ de vecteurs Perlin.

Canvas Perlin Particles
Page de l’effet →
Voir le code source
HTML
<div class="fx-0609-root">
  <canvas class="pff-canvas" role="img" aria-label="Particules bleues et violettes qui suivent les courants d'un champ de bruit de Perlin"></canvas>
</div>
CSS
.fx-0609-root,
.fx-0609-root * {
  box-sizing: border-box;
}

.fx-0609-root {
  position: relative;
  width: 100%;
  overflow: hidden;
  background: #0a0a0f;
}

/* Hauteur fixe par défaut ; --pff-height accepte aussi 100 % dans un parent de hauteur connue */
.fx-0609-root .pff-canvas {
  display: block;
  width: 100%;
  height: var(--pff-height, 300px);
}
JavaScript
(function () {
  // Perlin Flow Field : chaque particule suit la direction donnée par un bruit de Perlin 3D (x, y, temps).
  var SCALE = 0.0035;        // taille des courants : plus petit = courants plus larges
  var DRIFT = 0.00009;       // vitesse à laquelle le champ se transforme (unités de bruit par ms)
  var DENSITY = 480;         // une particule pour 480 px² de zone
  var TRAIL = 0.05;          // part de l'image effacée à chaque image (60 i/s) : plus petit = traînées plus longues
  var LIFE = 4000;           // durée de vie moyenne d'une particule (ms) avant de renaître ailleurs
  var HUE = 220;             // teinte de départ (bleu) ; les particules vont de HUE à HUE + 60

  var reduced = window.matchMedia ? window.matchMedia('(prefers-reduced-motion: reduce)') : null;

  // Bruit de Perlin « amélioré » (Ken Perlin, 2002) : gradients sur une grille 3D, interpolation lissée.
  function createNoise() {
    var p = new Uint8Array(512), i, j, t;
    for (i = 0; i < 256; i++) p[i] = i;
    for (i = 255; i > 0; i--) { j = Math.floor(Math.random() * (i + 1)); t = p[i]; p[i] = p[j]; p[j] = t; }
    for (i = 0; i < 256; i++) p[i + 256] = p[i];
    function fade(t) { return t * t * t * (t * (t * 6 - 15) + 10); }
    function mix(a, b, t) { return a + t * (b - a); }
    function grad(h, x, y, z) {
      h &= 15;
      var u = h < 8 ? x : y;
      var v = h < 4 ? y : (h === 12 || h === 14 ? x : z);
      return ((h & 1) ? -u : u) + ((h & 2) ? -v : v);
    }
    return function (x, y, z) {
      var X = Math.floor(x), Y = Math.floor(y), Z = Math.floor(z);
      x -= X; y -= Y; z -= Z;
      X &= 255; Y &= 255; Z &= 255;
      var u = fade(x), v = fade(y), w = fade(z);
      var A = p[X] + Y, AA = p[A] + Z, AB = p[A + 1] + Z;
      var B = p[X + 1] + Y, BA = p[B] + Z, BB = p[B + 1] + Z;
      return mix(
        mix(mix(grad(p[AA], x, y, z), grad(p[BA], x - 1, y, z), u),
            mix(grad(p[AB], x, y - 1, z), grad(p[BB], x - 1, y - 1, z), u), v),
        mix(mix(grad(p[AA + 1], x, y, z - 1), grad(p[BA + 1], x - 1, y, z - 1), u),
            mix(grad(p[AB + 1], x, y - 1, z - 1), grad(p[BB + 1], x - 1, y - 1, z - 1), u), v),
        w);
    };
  }

  function init(root) {
    // Une seule instance par racine, même si le script est collé plusieurs fois dans la page.
    if (root.hasAttribute('data-pff-ready')) return;
    root.setAttribute('data-pff-ready', '');
    var canvas = root.querySelector('.pff-canvas');
    var ctx = canvas && canvas.getContext ? canvas.getContext('2d') : null;
    if (!ctx) return;
    var noise = createNoise();
    var W = 0, H = 0, ratio = 0, time = Math.random() * 100;
    var particles = [], raf = 0, last = 0, visible = true;

    // Une particule renaît à un endroit au hasard : sans cela, toutes finissent dans les mêmes courants.
    function place(q) {
      q.x = Math.random() * W;
      q.y = Math.random() * H;
      q.life = LIFE * (0.5 + Math.random());
    }

    function seed() {
      var n = Math.max(60, Math.min(3000, Math.round(W * H / DENSITY)));
      particles = [];
      for (var i = 0; i < n; i++) {
        var q = { v: 0.5 + Math.random(), c: 'hsla(' + Math.round(HUE + Math.random() * 60) + ', 80%, 60%, 0.8)' };
        place(q);
        q.life *= Math.random();
        particles.push(q);
      }
    }

    function advance(dt) {
      var k = dt / 16.667;
      // Les traînées s'effacent vers la transparence : le fond visible est celui de la racine (CSS).
      ctx.globalCompositeOperation = 'destination-out';
      ctx.fillStyle = 'rgba(0, 0, 0, ' + (1 - Math.pow(1 - TRAIL, k)) + ')';
      ctx.fillRect(0, 0, W, H);
      ctx.globalCompositeOperation = 'source-over';
      for (var i = 0; i < particles.length; i++) {
        var q = particles[i];
        var angle = noise(q.x * SCALE, q.y * SCALE, time) * Math.PI * 4;
        q.x += Math.cos(angle) * q.v * k;
        q.y += Math.sin(angle) * q.v * k;
        if (q.x < 0) q.x += W; else if (q.x > W) q.x -= W;
        if (q.y < 0) q.y += H; else if (q.y > H) q.y -= H;
        q.life -= dt;
        if (q.life <= 0) place(q);
        ctx.fillStyle = q.c;
        ctx.beginPath();
        ctx.arc(q.x, q.y, 1, 0, Math.PI * 2);
        ctx.fill();
      }
    }

    // Mouvement réduit : le champ est figé et les particules tracent leurs lignes de courant une fois.
    function drawStill() {
      for (var i = 0; i < 160; i++) advance(16.667);
    }

    function loop(t) {
      var dt = last ? Math.min(t - last, 50) : 16.667;
      last = t;
      time += DRIFT * dt;
      advance(dt);
      raf = requestAnimationFrame(loop);
    }

    function stop() {
      if (raf) cancelAnimationFrame(raf);
      raf = 0;
    }

    function play() {
      if (raf || !W || !visible || (reduced && reduced.matches)) return;
      last = 0;
      raf = requestAnimationFrame(loop);
    }

    // Taille lue sur la zone affichée ; rien ne démarre tant qu'elle vaut 0 (onglet ou accordéon fermé).
    function resize(force) {
      var w = canvas.clientWidth, h = canvas.clientHeight;
      if (!w || !h) { stop(); return; }
      var r = window.devicePixelRatio || 1;
      if (force || w !== W || h !== H || r !== ratio) {
        W = w; H = h; ratio = r;
        canvas.width = Math.round(w * r);
        canvas.height = Math.round(h * r);
        ctx.setTransform(r, 0, 0, r, 0, 0);
        seed();
        if (reduced && reduced.matches) { stop(); drawStill(); }
      }
      play();
    }

    if (window.ResizeObserver) new ResizeObserver(function () { resize(false); }).observe(canvas);
    else window.addEventListener('resize', function () { resize(false); });
    if (window.IntersectionObserver) {
      new IntersectionObserver(function (entries) {
        visible = entries[entries.length - 1].isIntersecting;
        if (visible) play(); else stop();
      }).observe(canvas);
    }
    if (reduced && reduced.addEventListener) reduced.addEventListener('change', function () { stop(); resize(true); });
    resize(false);
  }

  document.querySelectorAll('.fx-0609-root').forEach(init);
})();

Geometric Tessellation

Mosaïque géométrique avec animations décalées.

CSS Grid Pattern

Recursive Circles

Cercles SVG emboîtés : chaque cercle en contient trois, qui respirent tour à tour.

SVG JS Recursive

Lissajous Curves

Courbes harmoniques en mouvement perpétuel.

Canvas Math Curves

Voronoi Pattern

Diagramme de Voronoi avec dégradés.

SVG JS Voronoi

Sine Wave Grid

Grille de points animés en onde sinusoïdale.

CSS JS Wave

Spirograph

Anneaux rotatifs créant des motifs hypnotiques.

CSS JS Rotation

Fractal Tree

Arbre fractal généré récursivement.

Canvas Fractal Recursive

Maze Generator

Labyrinthe généré avec l'algorithme de backtracking récursif.

Canvas Algorithm Recursive

Cellular Automata

Jeu de la Vie de Conway - simulation de vie artificielle.

Canvas Simulation Conway

PLAY

Text Mask Video

Titre rempli par une vraie vidéo, visible seulement dans les lettres.

CSS Text Video
Page de l’effet →
Voir le code source
HTML
<div class="fx-0619-root">
  <div class="tmv-stage">
    <video class="tmv-video" data-tmv-demo autoplay muted loop playsinline aria-hidden="true" tabindex="-1"></video>
    <h2 class="tmv-text">PLAY</h2>
  </div>
</div>
CSS
.fx-0619-root,
.fx-0619-root *,
.fx-0619-root *::before,
.fx-0619-root *::after {
  box-sizing: border-box;
}

.fx-0619-root {
  /* Réglages : taille du texte, fond du bloc, couleurs du repli et du clip de démo */
  --tmv-size: 4rem;
  --tmv-page: #0a0a0f;
  --tmv-height: 250px;
  --tmv-c1: #6366f1;
  --tmv-c2: #d946ef;
  --tmv-c3: #06b6d4;
  --tmv-c4: #f43f5e;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  min-height: var(--tmv-height);
  overflow: hidden;
  position: relative;
  background: var(--tmv-page);
  color: #fff;
  font-family: sans-serif;
}

/* Le bloc se fond dans la page (mode screen : le noir disparaît) ; sous la vidéo, un dégradé qui défile tant qu’elle n’a pas d’image */
.fx-0619-root .tmv-stage {
  position: relative;
  max-width: 100%;
  overflow: hidden;
  background: #000;
  mix-blend-mode: screen;
}

.fx-0619-root .tmv-stage::before,
.fx-0619-root .tmv-video {
  position: absolute;
  inset: 2px;
  display: block;
  width: calc(100% - 4px);
  height: calc(100% - 4px);
  pointer-events: none;
}

.fx-0619-root .tmv-stage::before {
  content: "";
  background: linear-gradient(90deg, var(--tmv-c1), var(--tmv-c2), var(--tmv-c3), var(--tmv-c4), var(--tmv-c1)) 0 50% / 400% 100%;
  animation: tmvFlow 3s linear infinite;
}

.fx-0619-root .tmv-video {
  object-fit: cover;
}

/* Texte blanc sur noir en mode multiply : la vidéo ne reste visible que dans les lettres */
.fx-0619-root .tmv-text {
  position: relative;
  margin: 0;
  padding: .3em .45em;
  font-size: var(--tmv-size);
  font-weight: 900;
  line-height: 1;
  text-align: center;
  overflow-wrap: anywhere;
  color: #fff;
  background: #000;
  mix-blend-mode: multiply;
}

/* Variante pour page claire : modes inversés (le blanc disparaît) */
.fx-0619-root.tmv-light {
  --tmv-page: #fff;
}

.fx-0619-root.tmv-light .tmv-stage {
  background: #fff;
  mix-blend-mode: multiply;
}

.fx-0619-root.tmv-light .tmv-text {
  color: #000;
  background: #fff;
  mix-blend-mode: screen;
}

/* La vidéo joue : le dégradé de repli s’arrête ; vidéo en échec : elle est masquée, le dégradé remplit le texte */
.fx-0619-root.tmv-playing .tmv-stage::before {
  animation: none;
}

.fx-0619-root.tmv-failed .tmv-video {
  visibility: hidden;
}

@keyframes tmvFlow {
  to {
    background-position: 400% 50%;
  }
}

@media (prefers-reduced-motion: reduce) {
  .fx-0619-root .tmv-stage::before {
    animation: none;
  }
}
JavaScript
(function () {
  var reduce = window.matchMedia ? window.matchMedia('(prefers-reduced-motion: reduce)') : null;
  function reduced() { return !!(reduce && reduce.matches); }

  // Clip de démonstration généré en local (aucun fichier) : retirez data-tmv-demo et donnez un src à la vidéo
  function demoClip(root, video) {
    var canvas = document.createElement('canvas');
    if (!canvas.captureStream) return null;
    canvas.width = 480;
    canvas.height = 270;
    var ctx = canvas.getContext('2d');
    var style = getComputedStyle(root);
    var colors = ['--tmv-c1', '--tmv-c2', '--tmv-c3', '--tmv-c4'].map(function (v, i) {
      return style.getPropertyValue(v).trim() || ['#6366f1', '#d946ef', '#06b6d4', '#f43f5e'][i];
    });
    var t = 0, last = 0, raf = 0;
    function draw() {
      var w = canvas.width, h = canvas.height;
      ctx.globalCompositeOperation = 'source-over';
      ctx.fillStyle = colors[0];
      ctx.fillRect(0, 0, w, h);
      for (var i = 1; i < 4; i++) {
        var x = w * (0.5 + 0.45 * Math.sin(t * (0.35 + i * 0.12) + i * 1.9));
        var y = h * (0.5 + 0.45 * Math.cos(t * (0.45 + i * 0.1) + i * 2.4));
        var g = ctx.createRadialGradient(x, y, 0, x, y, h * 0.95);
        g.addColorStop(0, colors[i]);
        g.addColorStop(1, 'rgba(0,0,0,0)');
        ctx.fillStyle = g;
        ctx.fillRect(0, 0, w, h);
      }
      ctx.globalCompositeOperation = 'lighter';
      for (var k = 0; k < 3; k++) {
        var bx = ((t * 70 + k * 190) % (w + 160)) - 80;
        var beam = ctx.createLinearGradient(bx - 50, 0, bx + 50, 0);
        beam.addColorStop(0, 'rgba(255,255,255,0)');
        beam.addColorStop(0.5, 'rgba(255,255,255,0.28)');
        beam.addColorStop(1, 'rgba(255,255,255,0)');
        ctx.fillStyle = beam;
        ctx.fillRect(bx - 50, 0, 100, h);
      }
    }
    function loop(now) {
      var dt = last ? Math.min(50, now - last) : 16;
      last = now;
      t += dt / 1000;
      draw();
      raf = requestAnimationFrame(loop);
    }
    draw();
    video.srcObject = canvas.captureStream(30);
    return {
      start: function () { if (!raf) { last = 0; raf = requestAnimationFrame(loop); } },
      stop: function () { cancelAnimationFrame(raf); raf = 0; },
      still: function () { draw(); }
    };
  }

  function init(root) {
    if (root.dataset.tmvReady) return;
    root.dataset.tmvReady = '1';
    var video = root.querySelector('.tmv-video');
    if (!video) return;
    var clip = null;
    if (video.hasAttribute('data-tmv-demo') && !video.getAttribute('src') && !video.querySelector('source')) {
      clip = demoClip(root, video);
    }
    var auto = video.autoplay;
    var visible = true, heldOff = false;
    // Classe tmv-playing dès qu’une image de la vidéo est affichée ; mouvement réduit = première image figée
    video.addEventListener('playing', function () {
      root.classList.add('tmv-playing');
      if (reduced()) video.pause();
    });
    video.addEventListener('play', function () { if (clip) clip.start(); });
    video.addEventListener('pause', function () { if (clip) clip.stop(); });
    video.addEventListener('emptied', function () { root.classList.remove('tmv-playing'); });
    // Aucune source lisible (fichier absent, format refusé) : classe tmv-failed, le texte garde le dégradé
    video.addEventListener('error', function () {
      setTimeout(function () {
        if (video.error || video.networkState === 3) {
          root.classList.remove('tmv-playing');
          root.classList.add('tmv-failed');
        }
      }, 0);
    }, true);
    video.addEventListener('canplay', function () {
      if (auto && visible && !heldOff && !reduced() && video.paused) {
        var c = video.play();
        if (c && c.catch) c.catch(function () {});
      }
    }, { once: true });

    function settle() {
      if (reduced()) {
        if (!root.classList.contains('tmv-playing')) {
          if (clip) clip.still();
          var p = video.play();
          if (p && p.catch) p.catch(function () {});
        } else {
          video.pause();
        }
      } else if (auto && visible) {
        var q = video.play();
        if (q && q.catch) q.catch(function () {});
      }
    }
    // Hors de l’écran, la vidéo se met en pause ; une vidéo en lecture automatique reprend au retour
    if ('IntersectionObserver' in window) {
      new IntersectionObserver(function (entries) {
        visible = entries[0].isIntersecting;
        if (!visible && !video.paused) { heldOff = auto; video.pause(); }
        else if (visible && heldOff) { heldOff = false; if (!reduced()) { var r = video.play(); if (r && r.catch) r.catch(function () {}); } }
      }).observe(root);
    }
    if (reduce && reduce.addEventListener) reduce.addEventListener('change', settle);
    settle();
  }

  function start() { document.querySelectorAll('.fx-0619-root').forEach(init); }
  if (document.readyState === 'loading') document.addEventListener('DOMContentLoaded', start);
  else start();
})();

Shape Clip Reveal

Contenu révélé à travers une forme circulaire au survol.

CSS Clip-path Hover

Image Mask Text

Image visible uniquement à travers le texte.

CSS Image Text

Circular Reveal

Masque circulaire qui s'étend depuis la position de la souris.

JS Clip-path Interactive

SVG Clip Path

Bloc découpé en étoile par un clipPath SVG, qui pivote au survol.

SVG Clip-path Shape

Gradient Mask Fade

Masque en dégradé radial : les bords du bloc se fondent dans la page.

CSS Mask Gradient

Moving Mask

Masque qui suit le mouvement de la souris.

JS Mask Mouse

Split Reveal

Deux volets qui s'écartent au survol pour découvrir le contenu du milieu.

CSS Clip-path Split

Blob Mask

Forme blob organique utilisée comme masque animé.

CSS SVG Mask Organic

Diagonal Clip

Animation clip-path diagonale avec plusieurs couches.

CSS Clip-path Layers

Questions fréquentes

Comment animer le traçage d'un SVG en CSS ? +

Utilisez stroke-dasharray et stroke-dashoffset. Définissez dasharray à la longueur totale du path, dashoffset à la même valeur, puis animez dashoffset vers 0. Le trait se dessine progressivement. Obtenez la longueur avec path.getTotalLength() en JS.

Comment faire du morphing SVG ? +

Le morphing nécessite deux paths avec le même nombre de points. Animez l'attribut d du path entre les deux formes. En CSS, utilisez une transition sur d (supporte dans Chrome/Edge). En JS, utilisez des librairies comme flubber ou GSAP MorphSVG.

Les animations SVG sont-elles meilleures que les GIF ? +

Oui. Le SVG est vectoriel (net à toute taille), léger (quelques Ko vs centaines de Ko pour un GIF), et contrôlable (pause, vitesse, couleurs via CSS). Un SVG animé fait 5-10x moins qu'un GIF équivalent.

Comment optimiser les performances des animations SVG ? +

Simplifiez les paths (moins de points), utilisez CSS pour les animations simples (transform, opacity), JS uniquement pour les animations complexes (morphing). Évitez d'animer des SVG complexes (>500 points) en boucle.

Peut-on animer des icônes SVG au hover ? +

Oui. Intégrez le SVG inline (pas en img), puis ciblez les éléments internes (path, circle, rect) avec CSS :hover sur le parent. Animez stroke, fill, transform. C'est la technique utilisée par les meilleurs sites.

Catégories similaires