Confetti, fireworks et particles

Créez des effets spéciaux festifs et mémorables pour vos interfaces : confetti, feux d'artifice, neige, particules flottantes et étincelles en JavaScript pur.

Introduction

Les effets spéciaux festifs comme les confetti, les feux d'artifice et les particules ajoutent une touche de magie à vos interfaces. Qu'il s'agisse de célébrer un achat, de féliciter un utilisateur ou simplement d'embellir une landing page, ces animations visuelles créent des moments mémorables.

Dans ce tutoriel, nous allons explorer 5 effets spéciaux différents en JavaScript pur : des confetti explosifs aux flocons de neige, en passant par les feux d'artifice Canvas. Chaque exemple est accompagné du code complet, prêt à copier dans votre projet.

💡
Bon à savoir

Tous les effets de cet article utilisent du JavaScript pur, sans aucune librairie externe. Ils combinent les approches DOM (éléments HTML animés) et Canvas (dessin pixel par pixel) selon les besoins.

1. Confetti Explosion

L'effet confetti est parfait pour célébrer les actions réussies : validation de formulaire, achat termine, objectif atteint. On crée des éléments DOM colores avec des animations CSS aléatoires.

Le principe

On génère dynamiquement des dizaines d'éléments <div> positionnes en absolu, chacun avec une couleur aléatoire, une direction et une vitesse de chute unique. L'animation CSS @keyframes gère la gravite et la rotation.

confetti.js
function createConfetti() {
  const container = document.getElementById('confettiBox');
  const colors = [
    '#6366f1', '#8b5cf6', '#d946ef',
    '#f59e0b', '#10b981', '#ef4444'
  ];

  for (let i = 0; i < 50; i++) {
    const confetti = document.createElement('div');
    const color = colors[Math.floor(Math.random() * colors.length)];
    const size = Math.random() * 8 + 6;
    const left = Math.random() * 100;
    const delay = Math.random() * 0.5;
    const duration = 2 + Math.random() * 2;

    confetti.style.cssText = `
      position: absolute;
      width: ${size}px;
      height: ${size}px;
      background: ${color};
      left: ${left}%;
      top: 0;
      border-radius: ${Math.random() > 0.5 ? '50%' : '2px'};
      animation: confettiFall ${duration}s ease-out
                 ${delay}s forwards;
    `;

    container.appendChild(confetti);
    setTimeout(() => confetti.remove(), 4500);
  }
}

L'animation CSS associée

confetti-keyframes.css
@keyframes confettiFall {
  0% {
    transform: translateY(0) rotate(0);
    opacity: 1;
  }
  100% {
    transform: translateY(300px) rotate(720deg);
    opacity: 0;
  }
}
💡
Astuce

Utilisez border-radius: 50% pour des confettis ronds et border-radius: 2px pour des rectangles. Alterner les formes rend l'effet plus naturel.

2. Particules flottantes

Les particules flottantes créent une ambiance immersive pour vos arrière-plans. Cet effet utilise l'API Canvas pour dessiner et animer des dizaines de particules avec des connexions entre elles.

Le principe

On initialise un tableau de particules avec des positions et vitesses aléatoires. À chaque frame, on déplace les particules, on les dessine et on trace des lignes entre celles qui sont proches les unes des autres.

particles.js
function initParticles(canvasId) {
  const canvas = document.getElementById(canvasId);
  const ctx = canvas.getContext('2d');
  canvas.width = canvas.offsetWidth;
  canvas.height = canvas.offsetHeight;

  const particles = [];
  const count = 40;
  const maxDist = 120;

  for (let i = 0; i < count; i++) {
    particles.push({
      x: Math.random() * canvas.width,
      y: Math.random() * canvas.height,
      vx: (Math.random() - 0.5) * 0.8,
      vy: (Math.random() - 0.5) * 0.8,
      r: Math.random() * 2 + 1
    });
  }

  function animate() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    particles.forEach(p => {
      p.x += p.vx;
      p.y += p.vy;
      if (p.x < 0 || p.x > canvas.width) p.vx *= -1;
      if (p.y < 0 || p.y > canvas.height) p.vy *= -1;

      ctx.beginPath();
      ctx.arc(p.x, p.y, p.r, 0, Math.PI * 2);
      ctx.fillStyle = 'rgba(99, 102, 241, 0.6)';
      ctx.fill();
    });

    // Lignes entre particules proches
    for (let i = 0; i < count; i++) {
      for (let j = i + 1; j < count; j++) {
        const dx = particles[i].x - particles[j].x;
        const dy = particles[i].y - particles[j].y;
        const dist = Math.sqrt(dx * dx + dy * dy);
        if (dist < maxDist) {
          ctx.strokeStyle =
            `rgba(99,102,241,${1 - dist/maxDist})`;
          ctx.lineWidth = 0.5;
          ctx.beginPath();
          ctx.moveTo(particles[i].x, particles[i].y);
          ctx.lineTo(particles[j].x, particles[j].y);
          ctx.stroke();
        }
      }
    }

    requestAnimationFrame(animate);
  }
  animate();
}
🔗
Lignes de connexion

Les lignes entre particules proches créent un effet de réseau (mesh). L'opacité diminue avec la distance pour un rendu naturel. Ajustez maxDist pour contrôler la densité du réseau.

3. Sparkles / Étincelles

Les étincelles (sparkles) sont des petites particules lumineuses qui suivent le curseur de la souris ou apparaissent autour d'un élément au survol. C'est un effet élégant pour attirer l'attention sur un CTA ou un élément premium.

Trail de curseur

On écoute les mouvements de souris et on crée des mini-éléments lumineux à chaque déplacement. Chaque étincelle grossit puis disparait en fondu.

sparkles.js
function initSparkles() {
  document.addEventListener('mousemove', (e) => {
    const sparkle = document.createElement('div');
    const size = Math.random() * 6 + 4;
    const colors = ['#fbbf24', '#f59e0b', '#fff'];
    const color = colors[
      Math.floor(Math.random() * colors.length)
    ];

    sparkle.style.cssText = `
      position: fixed;
      pointer-events: none;
      width: ${size}px;
      height: ${size}px;
      background: ${color};
      border-radius: 50%;
      left: ${e.clientX}px;
      top: ${e.clientY}px;
      box-shadow: 0 0 6px ${color};
      animation: sparkleFade 0.6s ease-out forwards;
      z-index: 9999;
    `;

    document.body.appendChild(sparkle);
    setTimeout(() => sparkle.remove(), 600);
  });
}

// Keyframes a ajouter en CSS :
// @keyframes sparkleFade {
//   0%   { transform: scale(0); opacity: 1; }
//   50%  { transform: scale(1); opacity: 0.8; }
//   100% { transform: scale(0); opacity: 0; }
// }
⚠️
Attention à la performance

Créer un élément DOM à chaque événement mousemove peut vite devenir coûteux. Utilisez un throttle (par exemple un appel tous les 50ms) pour limiter le nombre d'étincelles créées simultanément.

4. Neige qui tombe

L'effet neige est idéal pour les thèmes hivernaux, les pages de Noël ou tout simplement pour une ambiance douce et apaisante. On utilise Canvas pour dessiner des flocons qui tombent avec un léger mouvement horizontal.

Implementation Canvas

Chaque flocon a une taille, une vitesse et un décalage horizontal aléatoires. Quand un flocon atteint le bas du canvas, il est replacé en haut pour un effet continu.

snow.js
function initSnow(canvasId) {
  const canvas = document.getElementById(canvasId);
  const ctx = canvas.getContext('2d');
  canvas.width = window.innerWidth;
  canvas.height = window.innerHeight;

  const flakes = [];
  const count = 100;

  for (let i = 0; i < count; i++) {
    flakes.push({
      x: Math.random() * canvas.width,
      y: Math.random() * canvas.height,
      r: Math.random() * 3 + 1,
      speed: Math.random() * 1 + 0.5,
      wind: Math.random() * 0.5 - 0.25,
      opacity: Math.random() * 0.5 + 0.3
    });
  }

  function animate() {
    ctx.clearRect(0, 0, canvas.width, canvas.height);

    flakes.forEach(f => {
      f.y += f.speed;
      f.x += f.wind;

      // Replacer en haut si sorti
      if (f.y > canvas.height) {
        f.y = -5;
        f.x = Math.random() * canvas.width;
      }

      ctx.beginPath();
      ctx.arc(f.x, f.y, f.r, 0, Math.PI * 2);
      ctx.fillStyle =
        `rgba(255, 255, 255, ${f.opacity})`;
      ctx.fill();
    });

    requestAnimationFrame(animate);
  }
  animate();
}

Personnalisation

  • Nombre de flocons : ajustez count (50 pour subtil, 200 pour tempête)
  • Vitesse de chute : modifiez le multiplicateur dans speed
  • Vent : changez la plage de wind pour un mouvement latéral plus ou moins prononcé
  • Opacité : variez pour créer un effet de profondeur (flocons proches vs lointains)

5. Feux d'artifice

L'effet le plus spectaculaire : un feu d'artifice qui explose depuis un point central avec des particules colorées qui retombent en arc sous l'effet de la gravite. On utilise Canvas avec une simulation physique simplifiée.

La physique simplifiée

Chaque particule a une vélocité initiale dans une direction aléatoire. À chaque frame, on applique une gravite qui tire les particules vers le bas, créant l'arc naturel d'un feu d'artifice.

fireworks.js
function initFireworks(canvasId) {
  const canvas = document.getElementById(canvasId);
  const ctx = canvas.getContext('2d');
  canvas.width = canvas.offsetWidth;
  canvas.height = canvas.offsetHeight;

  let particles = [];
  const gravity = 0.03;

  function explode(x, y) {
    const count = 60;
    const hue = Math.random() * 360;

    for (let i = 0; i < count; i++) {
      const angle = (Math.PI * 2 / count) * i;
      const speed = Math.random() * 3 + 1;

      particles.push({
        x, y,
        vx: Math.cos(angle) * speed,
        vy: Math.sin(angle) * speed,
        life: 1,
        decay: Math.random() * 0.01 + 0.005,
        color: `hsl(${hue + Math.random()*30}, 100%, 60%)`
      });
    }
  }

  function animate() {
    // Fond semi-transparent pour trainee
    ctx.fillStyle = 'rgba(10, 10, 15, 0.15)';
    ctx.fillRect(0, 0, canvas.width, canvas.height);

    particles.forEach(p => {
      p.x += p.vx;
      p.y += p.vy;
      p.vy += gravity;  // Gravite
      p.life -= p.decay;

      ctx.beginPath();
      ctx.arc(p.x, p.y, 2, 0, Math.PI * 2);
      ctx.globalAlpha = p.life;
      ctx.fillStyle = p.color;
      ctx.fill();
    });

    ctx.globalAlpha = 1;
    // Nettoyer les particules mortes
    particles = particles.filter(p => p.life > 0);

    requestAnimationFrame(animate);
  }

  // Clic pour lancer un feu d'artifice
  canvas.addEventListener('click', (e) => {
    const rect = canvas.getBoundingClientRect();
    explode(e.clientX - rect.left, e.clientY - rect.top);
  });

  animate();
}
💡
Effet de traînée

Au lieu d'effacer complètement le canvas avec clearRect, on dessine un rectangle semi-transparent (rgba(10, 10, 15, 0.15)) à chaque frame. Cela laisse une traînée lumineuse derrière chaque particule, un effet très réaliste pour les feux d'artifice.

50+ effets Particules & FX prêts à copier

Aperçu live, customizer, code vanilla — zéro dépendance.

Voir les effets Particules

Bonnes pratiques

Avant de déployer ces effets en production, voici quelques recommandations essentielles pour garantir une expérience fluide :

Performance

  • Utilisez toujours requestAnimationFrame au lieu de setInterval pour les animations continues. Le navigateur optimise le rendu et met en pause l'animation quand l'onglet est inactif.
  • Limitez le nombre de particules : 50 à 100 suffisent pour un bel effet. Au-delà de 200, les performances chutent sur mobile.
  • Préférez Canvas au DOM pour les grandes quantités de particules. Manipuler des centaines d'éléments DOM est bien plus coûteux que de dessiner sur un canvas.

Nettoyage et mémoire

  • Supprimez les particules mortes avec filter() ou gérez un pool de particules réutilisables pour éviter les fuites mémoire.
  • Nettoyez les listeners quand le composant est démonté (important en SPA avec React, Vue, etc.).
  • Utilisez cancelAnimationFrame pour stopper les animations quand elles ne sont plus visibles.

Mobile et accessibilité

responsive-check.js
// Reduire les particules sur mobile
const isMobile = window.innerWidth < 768;
const particleCount = isMobile ? 25 : 60;

// Respecter prefers-reduced-motion
const prefersReduced = window
  .matchMedia('(prefers-reduced-motion: reduce)')
  .matches;

if (!prefersReduced) {
  initParticles('myCanvas', particleCount);
}
⚠️
Accessibilité

Vérifiez toujours prefers-reduced-motion avant de lancer des animations automatiques. Certains utilisateurs souffrent de troubles vestibulaires et les animations peuvent provoquer des nausées ou des vertiges.

Conclusion

Les effets spéciaux festifs sont un excellent moyen de rendre vos interfaces plus vivantes et mémorables. Que ce soit pour célébrer une action utilisateur avec des confettis, créer une ambiance hivernale avec de la neige ou impressionner avec un feu d'artifice, JavaScript offre toute la puissance nécessaire.

L'approche DOM (confetti, sparkles) est idéale pour des effets ponctuels avec peu d'éléments. L'approche Canvas (particules, neige, fireworks) est préférable quand le nombre d'éléments augmente. Dans tous les cas, pensez toujours à la performance, au nettoyage mémoire et à l'accessibilité.

🎨
Allez plus loin

Retrouvez des effets spéciaux prêts à l'emploi dans notre bibliothèque d'effets, avec code copiable en un clic et personnalisation en temps réel.

Les effets de cet article dans le catalogue

Les mêmes techniques, prêtes à copier : aperçu en direct, réglages et code complet sur la page de leur catégorie.

À lire aussi

Trois articles proches pour aller plus loin.