Comment animer des graphiques et des chiffres sans bibliothèque ?

Les petites visualisations de données, compteurs, anneaux de progression, graphiques en barres ou en courbes, se dessinent avec HTML, CSS et SVG seuls. Les barres grandissent avec une transformation CSS, les anneaux et les courbes animent stroke-dashoffset en SVG, et les compteurs s'incrémentent en JavaScript quand ils entrent à l'écran, détectés par IntersectionObserver.

Comment choisir, performances et accessibilité
  • Utilisez Animated Counter ou Stat Cards pour les chiffres clés d'une page d'accueil, Progress Ring ou Gauge Meter pour un taux d'avancement, et Line Chart Draw ou Sparkline pour les tendances d'un tableau de bord.
  • Laissez la valeur finale dans le HTML pour qu'elle soit juste sans animation et lue par les lecteurs d'écran, nommez les axes et les unités, et passez à une bibliothèque de graphiques seulement pour le zoom, des infobulles nombreuses ou des données en direct.
  • Animated Counter est gratuit avec son code complet ; les autres sont inclus dans Premium.
8 547 Utilisateurs actifs

Animated Counter

Compteur qui s'anime vers la valeur cible.

JS Numbers
Page de l’effet →
Voir le code source
HTML
<div class="fx-0223-root">
  <div class="ctup-box">
    <span class="ctup-value" data-target="8547">8 547</span>
    <span class="ctup-label">Utilisateurs actifs</span>
  </div>
</div>
CSS
.fx-0223-root,
.fx-0223-root *,
.fx-0223-root *::before,
.fx-0223-root *::after {
  box-sizing: border-box
}

.fx-0223-root {
  --ctup-bg: rgb(26, 26, 36);
  --ctup-from: #6366f1;
  --ctup-to: #d946ef;
  --ctup-muted: rgba(255, 255, 255, .6);
  --ctup-size: 3rem;
  --ctup-height: 250px;
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  min-height: var(--ctup-height);
  overflow: hidden;
  position: relative;
  background: var(--ctup-bg);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.ctup-box {
  display: flex;
  flex-direction: column;
  align-items: center;
  gap: 8px;
}

.ctup-value {
  font-size: var(--ctup-size);
  font-weight: 800;
  font-variant-numeric: tabular-nums;
  white-space: nowrap;
  background: linear-gradient(135deg, var(--ctup-from), var(--ctup-to));
  -webkit-background-clip: text;
  -webkit-text-fill-color: transparent;
  background-clip: text;
}

.ctup-label {
  font-size: 0.875rem;
  color: var(--ctup-muted);
  text-transform: uppercase;
  letter-spacing: 2px;
}

/* Valeur finale pour les lecteurs d'écran (le chiffre qui défile est masqué pour eux) */
.ctup-sr {
  position: absolute;
  width: 1px;
  height: 1px;
  margin: -1px;
  padding: 0;
  overflow: hidden;
  clip: rect(0 0 0 0);
  clip-path: inset(50%);
  white-space: nowrap;
  border: 0;
}
JavaScript
(function () {
  'use strict';
  // Animated Counter : le chiffre compte de 0 jusqu'à data-target quand il est à moitié visible, une seule fois.
  var calm = window.matchMedia ? window.matchMedia('(prefers-reduced-motion: reduce)') : { matches: false };

  // Langue de la page (lang le plus proche) : 8 547 en français, 8,547 en anglais
  function pageLang(el) {
    var host = el.closest('[lang]');
    return (host && host.lang) || navigator.language || 'fr';
  }

  function init(el) {
    if (el.hasAttribute('data-ctup-ready')) return;
    el.setAttribute('data-ctup-ready', '');
    var raw = (el.getAttribute('data-target') || '0').trim();
    var target = parseFloat(raw) || 0;
    var decimals = raw.indexOf('.') > -1 ? raw.split('.')[1].length : 0;
    var duration = parseFloat(el.getAttribute('data-duration')) || 2000;
    var fmt = new Intl.NumberFormat(pageLang(el), {
      minimumFractionDigits: decimals,
      maximumFractionDigits: decimals
    });

    // Les lecteurs d'écran lisent la valeur finale, jamais les étapes du comptage
    var sr = document.createElement('span');
    sr.className = 'ctup-sr';
    sr.textContent = fmt.format(target);
    el.parentNode.insertBefore(sr, el.nextSibling);
    el.setAttribute('aria-hidden', 'true');

    if (calm.matches || !('IntersectionObserver' in window)) {
      el.textContent = fmt.format(target);
      return;
    }
    el.textContent = fmt.format(0);

    function count() {
      if (calm.matches) {
        el.textContent = fmt.format(target);
        return;
      }
      var start = performance.now();
      requestAnimationFrame(function step(t) {
        var p = Math.min((t - start) / duration, 1);
        var v = target * (1 - Math.pow(1 - p, 3)); // ease-out cubique
        el.textContent = fmt.format(decimals ? v : Math.floor(v));
        if (p < 1) requestAnimationFrame(step);
        else el.textContent = fmt.format(target);
      });
    }

    var obs = new IntersectionObserver(function (entries) {
      if (!entries[0].isIntersecting) return;
      obs.disconnect();
      count();
    }, { threshold: 0.5 });
    obs.observe(el);
  }

  document.querySelectorAll('.fx-0223-root .ctup-value[data-target]').forEach(init);
})();

Progress Ring

Anneau de progression circulaire animé.

SVG CSS JS

Bar Chart Animated

Graphique en barres avec effet de croissance.

CSS JS Stagger

Line Chart Draw

Ligne qui se dessine progressivement.

SVG Path

Pie Chart Reveal

Camembert avec segments qui apparaissent.

SVG Segments

Gauge Meter

Jauge en demi-cercle dont l'aiguille pivote jusqu'à la valeur, du vert au rouge.

SVG CSS JS

Stat Cards

Cartes statistiques avec compteurs animés.

JS Cards

Comparison Bars

Barres horizontales pour comparer des valeurs.

CSS JS Progress

Donut Chart

Graphique en anneau dont les parts apparaissent l'une après l'autre.

SVG Circular

Sparkline

Chiffre-clé avec mini-courbe de tendance qui se dessine.

SVG Trend

Counter Animation CSS

Compteur animé en pure CSS avec @property.

CSS @property

Circular Progress SVG

Cercle de progression avec animation.

SVG CSS JS

Animated Bar Chart

Graphique à barres avec croissance animée.

CSS Animation

Donut Chart CSS

Graphique en anneau en conic-gradient, qui apparaît en tournant.

CSS Gradient

Gauge Meter CSS

Jauge en demi-cercle en CSS seul.

CSS Border

Step Progress Indicator

Indicateur d'étapes avec animation.

CSS Steps

Star Rating Animated

Vraie note de 1 à 5 étoiles : clic, toucher ou clavier, envoyée avec le formulaire.

JS Interactive

Line Chart Drawing

Graphique linéaire SVG avec dessin animé.

SVG Path

Counter Odometer

Chiffres qui roulent comme un compteur kilométrique, chacun dans sa case.

CSS Transform Counter

Animated Donut Chart

Graphique en anneau avec légende : les parts glissent vers les nouvelles valeurs (conic-gradient et @property).

CSS @property conic-gradient

Live Sparkline

Mini-courbe qui se trace à l'apparition et glisse à chaque nouvelle valeur.

SVG JS Path

Needle Gauge

Jauge à aiguille en demi-cadran, cinq zones colorées, valeur réglée par data-value.

CSS JS Transform Gauge

Bar Chart Race

Barres horizontales classées : quand une valeur change, elles s'allongent et les lignes glissent à leur nouveau rang.

CSS Transition Race

Morphing Pie Chart

Camembert dont les parts glissent d'un jeu de données à l'autre ; légende en pourcentages.

CSS @property Morph

Animated Stat Counter

Compteurs qui montent vers leur valeur en ralentissant, avec séparateur de milliers, préfixe et suffixe.

JS rAF Easing

Progress Steps

Étape en cours en indigo, étapes passées en vert, trait qui se remplit.

CSS JS Steps

Data Table Row Animation

Vrai tableau HTML : les lignes modifiées glissent en place et s'illuminent une à une ; surlignage au survol.

CSS JS Table

Heatmap Cell Animation

Calendrier de chaleur : cases colorées selon leur valeur, en vague.

CSS Grid Heatmap

Year in Pixels

Le calendrier « un jour = une tuile », en version haut de gamme : des tuiles en relief éclairées par le dessus, qui s'enfoncent au clic et se remplissent d'une couleur chaude propagée depuis le point de contact (quatre intensités, de la braise à l'or). Les jours consécutifs forment une série : un tracé lumineux continu les relie dans l'ordre et un flux doré le parcourt jusqu'à aujourd'hui, et les compteurs « série » et « record » roulent. La vue par défaut cadre les dernières semaines autour d'aujourd'hui, l'année entière est à un clic. Clavier, info-bulle, jours à venir non cochables ; avec prefers-reduced-motion, tout s'affiche directement, sans flux ni onde.

💡 Idéal pour : tableaux de bord d'habitudes ou de sport, bilan « mon année en pixels », suivi de résolutions, statistiques d'une appli (séries, records).

CSS + SVG Dataviz Série Accessible Premium

Questions fréquentes

Comment animer un graphique en barres en CSS ? +

Définissez la hauteur finale avec une variable CSS (--value). Partez de height:0 et animez vers height:var(--value) avec @keyframes. Ajoutez un transition-delay incremental pour que les barres apparaissent en sequence.

Comment créer un graphique circulaire animé en CSS ? +

Utilisez un conic-gradient avec la valeur en pourcentage. Animez la valeur avec @property (CSS Houdini) pour une transition fluide. Alternative : SVG circle avec stroke-dasharray animé.

Comment faire un compteur animé en JavaScript ? +

Utilisez requestAnimationFrame avec une interpolation linéaire ou ease-out. Calculez la valeur courante entre 0 et la cible, mettez à jour le textContent. Durée recommandée : 1-2 secondes.

Quelle librairie pour la data visualization web ? +

Pour des graphiques simples, le CSS et JavaScript vanilla suffisent (comme nos exemples). Pour des dashboards complexes, Chart.js (léger) ou D3.js (puissant). Évitez les librairies lourdes pour des graphiques simples.

Comment rendre un graphique accessible ? +

Ajoutez un aria-label avec la description des données. Utilisez des couleurs avec contraste suffisant. Fournissez une alternative textuelle (tableau HTML) via un lien 'Voir les données'. Évitez de transmettre l'information uniquement par la couleur.