Comment créer des effets liquides, des blobs et des metaballs ?

Les effets liquides font couler, fusionner et se séparer des formes comme un fluide. Les metaballs s'obtiennent en général avec un filtre SVG, un flou gaussien suivi d'une matrice de couleurs très contrastée (la technique « goo ») ; les blobs se déforment en animant border-radius ou des tracés SVG, et les ondulations d'eau utilisent canvas ou WebGL.

Comment choisir, performances et accessibilité
  • Utilisez Blob Morph ou Fluid Gradient comme accent décoratif discret, Liquid Button pour un appel à l'action ludique, et Metaballs ou Lava Lamp pour un héros qui attire l'œil.
  • Les filtres SVG coûtent cher sur de grandes surfaces : limitez-les à de petites zones, mettez en pause les animations hors de l'écran et affichez une forme fixe pour prefers-reduced-motion.
  • Metaballs, Blob Morph, AI Shape Morph, AI Color Shift, Generative Glitch et AI Typo Morph sont gratuits avec leur code ; les autres effets liquides sont inclus dans Premium.

Metaballs

Blobs organiques qui fusionnent ensemble avec un effet de tension de surface.

Canvas Animation Organic
Page de l’effet →
Voir le code source
HTML
<div class="fx-0391-root">
  <div class="metaballs-container">
    <canvas class="metaballs-canvas"></canvas>
  </div>
</div>
CSS
.fx-0391-root,
.fx-0391-root *,
.fx-0391-root *::before,
.fx-0391-root *::after {
  box-sizing: border-box
}

.fx-0391-root {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 250px;
  overflow: hidden;
  position: relative;
  background: rgb(26, 26, 36);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.metaballs-container {
  width: 100%;
  height: 100%;
  position: relative;
}

.metaballs-canvas {
  display: block;
  width: 100%;
  height: 100%;
}
JavaScript
(function() {
  // ============================================
  // METABALLS - Canvas 2D, champ calculé pixel par pixel
  // Réglages par bloc (facultatifs) sur .fx-0391-root :
  //   data-balls="3"            nombre de boules (6 par défaut)
  //   data-color="99,102,241"   couleur des boules en R,V,B (indigo par défaut)
  // ============================================
  var reduce = window.matchMedia('(prefers-reduced-motion: reduce)');

  document.querySelectorAll('.fx-0391-root').forEach(function(root) {
    var canvas = root.querySelector('.metaballs-canvas');
    if (!canvas) return;
    var ctx = canvas.getContext('2d');
    var container = canvas.parentElement;

    var numBalls = parseInt(root.getAttribute('data-balls'), 10) || 6;
    var color = (root.getAttribute('data-color') || '99,102,241').split(',').map(Number);
    var background = [26, 26, 36];
    var PIXEL_BUDGET = 650000;

    var w = 0, h = 0, scale = 1, imageData = null;
    var balls = [];
    var raf = 0, visible = true;

    function resize() {
      w = container.clientWidth;
      h = container.clientHeight;
      // Écran Retina : jusqu'à 2 pixels de canvas par pixel CSS, dans la limite de PIXEL_BUDGET pixels
      // calculés par image (le champ est calculé pixel par pixel : sur un grand cadre, la fluidité passe d'abord)
      scale = Math.max(1, Math.min(window.devicePixelRatio || 1, 2, Math.sqrt(PIXEL_BUDGET / Math.max(1, w * h))));
      canvas.width = Math.max(1, Math.round(w * scale));
      canvas.height = Math.max(1, Math.round(h * scale));
      imageData = ctx.createImageData(canvas.width, canvas.height);
      if (!balls.length) {
        for (var i = 0; i < numBalls; i++) {
          var radius = 30 + Math.random() * 40;
          balls.push({
            x: radius + Math.random() * Math.max(0, w - 2 * radius),
            y: radius + Math.random() * Math.max(0, h - 2 * radius),
            vx: (Math.random() - 0.5) * 2,
            vy: (Math.random() - 0.5) * 2,
            radius: radius
          });
        }
      }
      keepInside();
      drawMetaballs();
      start();
    }

    // Une boule ne sort jamais du cadre, même après un rétrécissement
    function keepInside() {
      for (var i = 0; i < balls.length; i++) {
        var ball = balls[i];
        ball.x = w > 2 * ball.radius ? Math.min(Math.max(ball.x, ball.radius), w - ball.radius) : w / 2;
        ball.y = h > 2 * ball.radius ? Math.min(Math.max(ball.y, ball.radius), h - ball.radius) : h / 2;
      }
    }

    function drawMetaballs() {
      var W = canvas.width, H = canvas.height;
      var data = imageData.data;
      var n = balls.length;
      var bx = [], by = [], r2 = [], dy2 = [];
      for (var i = 0; i < n; i++) {
        bx[i] = balls[i].x * scale;
        by[i] = balls[i].y * scale;
        r2[i] = balls[i].radius * balls[i].radius * scale * scale;
      }
      var soft = scale * scale; // le « + 1 » de r² / (d² + 1), en pixels de l'écran
      var idx = 0;

      for (var y = 0; y < H; y++) {
        for (i = 0; i < n; i++) dy2[i] = (y - by[i]) * (y - by[i]) + soft;
        for (var x = 0; x < W; x++) {
          var sum = 0;
          for (i = 0; i < n; i++) {
            var dx = x - bx[i];
            sum += r2[i] / (dx * dx + dy2[i]);
          }

          if (sum > 1) {
            var intensity = Math.min(sum - 1, 1) * 50; // le cœur s'éclaircit là où les champs s'additionnent
            data[idx] = color[0] + intensity;
            data[idx + 1] = color[1] + intensity;
            data[idx + 2] = color[2] + intensity;
          } else {
            data[idx] = background[0];
            data[idx + 1] = background[1];
            data[idx + 2] = background[2];
          }
          data[idx + 3] = 255;
          idx += 4;
        }
      }

      ctx.putImageData(imageData, 0, 0);
    }

    function updateBalls() {
      for (var i = 0; i < balls.length; i++) {
        var ball = balls[i];
        ball.x += ball.vx;
        ball.y += ball.vy;

        if (ball.x < ball.radius) ball.vx = Math.abs(ball.vx);
        if (ball.x > w - ball.radius) ball.vx = -Math.abs(ball.vx);
        if (ball.y < ball.radius) ball.vy = Math.abs(ball.vy);
        if (ball.y > h - ball.radius) ball.vy = -Math.abs(ball.vy);
      }
      keepInside();
    }

    function animate() {
      raf = 0;
      updateBalls();
      drawMetaballs();
      start();
    }

    // La boucle ne tourne que si le bloc est à l'écran, l'onglet visible et le mouvement autorisé
    function start() {
      if (!raf && visible && !document.hidden && !reduce.matches) raf = requestAnimationFrame(animate);
    }

    if ('IntersectionObserver' in window) {
      new IntersectionObserver(function(entries) {
        visible = entries[0].isIntersecting;
        if (visible) start();
        else if (raf) { cancelAnimationFrame(raf); raf = 0; }
      }).observe(root);
    }
    document.addEventListener('visibilitychange', start);

    if ('ResizeObserver' in window) new ResizeObserver(resize).observe(container);
    else window.addEventListener('resize', resize);
    resize();
  });
})();

Water Ripple

Effet d'ondulation réaliste simulé avec propagation des vagues.

Canvas Interactive Physics

Liquid Button

Bouton avec effet de remplissage liquide animé au survol.

CSS Hover Button

Dripping Text

Texte avec effet de gouttes qui tombent continuellement.

CSS SVG Text

Bubble Rise

Bulles translucides qui montent avec des mouvements organiques.

CSS Animation Particles

Lava Lamp

Blobs flottants style lampe à lave, flous et colorés, qui montent et redescendent.

CSS Animation Blur

Mercury Drops

Gouttes métalliques avec reflets réalistes et rebonds élastiques.

CSS Gradient Metallic

Wave Surface

Surface d'eau animée avec plusieurs couches de vagues.

CSS SVG Layers

Splash Effect

Effet d'éclaboussure interactif avec particules et gouttelettes.

Canvas Interactive Particles

Fluid Gradient

Gradient animé qui coule comme un liquide avec mouvement organique.

CSS Gradient Blur

WebGL Fluid Simulation

De l'encre néon coule sous le curseur, tourbillonne et s'estompe ; un clic fait éclater une nouvelle couleur. Sans interaction, le mouvement continue tout seul.

💡 Idéal pour : hero de landing page, accueil d'agence, page 404 ludique.

WebGL Shader Fluide Interactif Bloom Premium
BLOB

Blob Morph

Forme organique qui se métamorphose continuellement entre différentes silhouettes fluides via l'animation du border-radius.

CSS Organique Keyframes
Page de l’effet →
Voir le code source
HTML
<div class="fx-0401-root">
  <div class="blob-morph">BLOB</div>
</div>
CSS
.fx-0401-root,
.fx-0401-root *,
.fx-0401-root *::before,
.fx-0401-root *::after {
  box-sizing: border-box
}

.fx-0401-root {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 250px;
  overflow: hidden;
  position: relative;
  background: rgb(26, 26, 36);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.blob-morph {
  width: 180px;
  height: 180px;
  background: linear-gradient(135deg, #a855f7, #ec4899);
  animation: blobMorph 8s ease-in-out infinite;
  display: flex;
  align-items: center;
  justify-content: center;
  font-weight: 700;
  font-size: 1rem;
  color: white;
  text-shadow: 0 2px 8px rgba(0, 0, 0, 0.3);
  box-shadow:
    0 0 40px rgba(168, 85, 247, 0.4),
    0 0 80px rgba(236, 72, 153, 0.2);
  transition: transform 0.3s ease;
}

.blob-morph:hover {
  transform: scale(1.08);
}

@keyframes blobMorph {
  0% {
    border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%;
  }

  14% {
    border-radius: 40% 60% 70% 30% / 50% 60% 40% 50%;
  }

  28% {
    border-radius: 70% 30% 50% 50% / 30% 50% 60% 70%;
  }

  42% {
    border-radius: 30% 60% 70% 40% / 50% 30% 70% 60%;
  }

  56% {
    border-radius: 50% 50% 30% 70% / 70% 40% 60% 30%;
  }

  70% {
    border-radius: 40% 70% 60% 30% / 40% 60% 30% 70%;
  }

  84% {
    border-radius: 70% 40% 40% 60% / 60% 50% 50% 40%;
  }

  100% {
    border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%;
  }
}

/* Mouvement réduit : une silhouette fixe (celle du début de la boucle), sans zoom au survol. */
@media (prefers-reduced-motion: reduce) {
  .fx-0401-root .blob-morph {
    animation: none;
    border-radius: 60% 40% 30% 70% / 60% 30% 70% 40%
  }

  .fx-0401-root .blob-morph:hover { transform: none }
}
JavaScript
/* CSS pur — aucun JavaScript requis */

Icon Morph

Icône hamburger qui se transforme en croix de fermeture avec des transitions CSS fluides au clic.

CSS JS Interaction

Shape Shifter

Forme qui cycle entre cercle, carré, triangle, hexagone et étoile grâce aux transitions clip-path.

CSS clip-path Cycle

Button Morph

Bouton qui se métamorphose en spinner de chargement, puis en coche de validation au clic.

CSS JS UX

Text Morph

Texte qui se métamorphose entre plusieurs mots avec un effet de flou et opacité pour une transition douce.

CSS JS Typographie

Card Morph

Carte compacte qui s'agrandit et se transforme en panneau détaillé au clic avec des transitions fluides.

CSS JS Layout

SVG Path Morph

Forme SVG qui se métamorphose entre étoile, cœur et cercle en animant l'attribut de chemin.

SVG JS Path

Liquid Morph

Trois gouttes qui fusionnent et se séparent grâce à un filtre SVG « goo » (flou + seuil) écrit dans le HTML.

CSS SVG Filter Organique

Avatar Morph

Avatar circulaire qui se transforme en carte rectangulaire avec informations utilisateur au survol.

CSS Hover Profil

Toggle Morph

Interrupteur dont le curseur change de forme en glissant : le cercle se déforme en pilule avant de reprendre sa forme initiale.

CSS JS UI

AI & Intelligence

AI Shape Morph

Forme dessinée sur canvas qui se transforme en douceur entre plusieurs silhouettes : cercle, étoile, carré.

Canvas Morphing Animation
Page de l’effet →
Voir le code source
HTML
<div class="fx-0411-root">
  <div class="ai-shape-morph-container">
    <canvas class="ai-shape-canvas"></canvas>
  </div>
</div>
CSS
.fx-0411-root,
.fx-0411-root *,
.fx-0411-root *::before,
.fx-0411-root *::after {
  box-sizing: border-box
}

.fx-0411-root {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 250px;
  overflow: hidden;
  position: relative;
  background: rgb(26, 26, 36);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.ai-shape-morph-container {
  width: 100%;
  height: 100%;
  display: flex;
  align-items: center;
  justify-content: center;
}

.ai-shape-morph-container .ai-shape-canvas {
  display: block;
  width: 100%;
  height: 100%;
}
JavaScript
(function() {
  // ============================================
  // AI & Intelligence Effects
  // ============================================

  // 1. AI Shape Morph
  // Une instance par bloc .fx-0411-root : plusieurs copies cohabitent sur une page
  document.querySelectorAll('.fx-0411-root').forEach(function(root) {
    const canvas = root.querySelector('.ai-shape-canvas');
    if (!canvas) return;
    const ctx = canvas.getContext('2d');
    // Mouvement réduit demandé : une étoile fixe, aucune boucle
    const reduceMotion = window.matchMedia('(prefers-reduced-motion: reduce)').matches;
    let W = 0,
      H = 0;

    // Taille interne = taille affichée × devicePixelRatio (net sur écran Retina) ;
    // le dessin reste en pixels CSS grâce à setTransform.
    function resize() {
      const dpr = window.devicePixelRatio || 1;
      W = canvas.clientWidth;
      H = canvas.clientHeight;
      canvas.width = Math.round(W * dpr);
      canvas.height = Math.round(H * dpr);
      ctx.setTransform(dpr, 0, 0, dpr, 0, 0);
      if (reduceMotion) draw();
    }

    const shapes = [
      // Circle points
      Array.from({
        length: 12
      }, (_, i) => {
        const a = (i / 12) * Math.PI * 2;
        return {
          x: Math.cos(a) * 0.35,
          y: Math.sin(a) * 0.35
        };
      }),
      // Star points
      Array.from({
        length: 12
      }, (_, i) => {
        const a = (i / 12) * Math.PI * 2;
        const r = i % 2 === 0 ? 0.4 : 0.2;
        return {
          x: Math.cos(a) * r,
          y: Math.sin(a) * r
        };
      }),
      // Square points
      Array.from({
        length: 12
      }, (_, i) => {
        const t = i / 12;
        const side = Math.floor(t * 4);
        const p = (t * 4) % 1;
        const coords = [{
            x: -0.3 + p * 0.6,
            y: -0.3
          },
          {
            x: 0.3,
            y: -0.3 + p * 0.6
          },
          {
            x: 0.3 - p * 0.6,
            y: 0.3
          },
          {
            x: -0.3,
            y: 0.3 - p * 0.6
          }
        ];
        return coords[side];
      })
    ];

    let currentShape = reduceMotion ? 1 : 0;
    let progress = 0;
    let morphPoints = shapes[currentShape].map(p => ({
      ...p
    }));
    let raf = 0;
    let visible = true;

    function draw() {
      const nextShape = (currentShape + 1) % shapes.length;
      const eased = 0.5 - 0.5 * Math.cos(progress * Math.PI);

      for (let i = 0; i < morphPoints.length; i++) {
        morphPoints[i].x = shapes[currentShape][i].x + (shapes[nextShape][i].x - shapes[currentShape][i].x) * eased;
        morphPoints[i].y = shapes[currentShape][i].y + (shapes[nextShape][i].y - shapes[currentShape][i].y) * eased;
      }

      ctx.clearRect(0, 0, W, H);
      const cx = W / 2;
      const cy = H / 2;
      const scale = Math.min(W, H);

      // Dégradé proportionnel à la forme : ±80 px pour un cadre de 250 px de haut
      const g = scale * 0.32;
      const gradient = ctx.createLinearGradient(cx - g, cy - g, cx + g, cy + g);
      gradient.addColorStop(0, '#6366f1');
      gradient.addColorStop(0.5, '#a855f7');
      gradient.addColorStop(1, '#ec4899');

      // Départ au milieu du dernier côté : les 12 points servent tous de points de contrôle,
      // la forme se referme sans arête droite
      const n = morphPoints.length;
      ctx.beginPath();
      ctx.moveTo(cx + (morphPoints[n - 1].x + morphPoints[0].x) / 2 * scale, cy + (morphPoints[n - 1].y + morphPoints[0].y) / 2 * scale);
      for (let i = 0; i < n; i++) {
        const curr = morphPoints[i];
        const next = morphPoints[(i + 1) % n];
        const cpx = cx + (curr.x + next.x) / 2 * scale;
        const cpy = cy + (curr.y + next.y) / 2 * scale;
        ctx.quadraticCurveTo(cx + curr.x * scale, cy + curr.y * scale, cpx, cpy);
      }
      ctx.closePath();
      ctx.fillStyle = gradient;
      ctx.fill();
    }

    function animate() {
      progress += 0.008;
      if (progress >= 1) {
        progress = 0;
        currentShape = (currentShape + 1) % shapes.length;
      }
      draw();
      // Hors écran, la boucle s'arrête ; l'IntersectionObserver la relance au retour
      raf = visible ? requestAnimationFrame(animate) : 0;
    }

    resize();
    if ('ResizeObserver' in window) new ResizeObserver(resize).observe(canvas);
    else window.addEventListener('resize', resize);

    if (!reduceMotion) {
      if ('IntersectionObserver' in window) {
        new IntersectionObserver(function(entries) {
          visible = entries[0].isIntersecting;
          if (visible && !raf) raf = requestAnimationFrame(animate);
        }).observe(canvas);
      }
      raf = requestAnimationFrame(animate);
    }
  });
})();

Generative Flow Field

Champ de flux généré par un bruit lissé, avec des particules qui suivent les lignes de force.

Canvas Bruit Particules

Neural Net Viz

Graphe animé de neurones avec des connexions et des pulsations lumineuses décoratives.

Canvas Réseau AI

AI Color Shift

Palette de couleurs générée dynamiquement en OKLCH avec transitions fluides entre harmonies.

CSS OKLCH Couleurs
Page de l’effet →
Voir le code source
HTML
<div class="fx-0414-root">
  <div class="ai-color-shift">
    <div class="ai-color-swatch"></div>
    <div class="ai-color-swatch"></div>
    <div class="ai-color-swatch"></div>
    <div class="ai-color-swatch"></div>
    <div class="ai-color-swatch"></div>
  </div>
</div>
CSS
.fx-0414-root,
.fx-0414-root *,
.fx-0414-root *::before,
.fx-0414-root *::after {
  box-sizing: border-box
}

.fx-0414-root {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 250px;
  overflow: hidden;
  position: relative;
  background: rgb(26, 26, 36);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.ai-color-shift {
  width: 100%;
  height: 100%;
  display: grid;
  grid-template-columns: repeat(5, 1fr);
  gap: 8px;
  padding: 20px;
}

.ai-color-swatch {
  border-radius: 12px;
}
JavaScript
(function() {
  // AI Color Shift : cinq teintes OKLCH espacées de 72° qui tournent ensemble
  var reduce = window.matchMedia('(prefers-reduced-motion: reduce)');
  document.querySelectorAll('.ai-color-shift').forEach(function(container) {
    var swatches = container.querySelectorAll('.ai-color-swatch');
    var elapsed = 0; // secondes d'animation écoulées
    var last = 0;
    var raf = 0;
    var onScreen = true;

    function paint() {
      var hueBase = (elapsed * 18) % 360; // 18° par seconde : un tour en 20 s
      swatches.forEach(function(swatch, i) {
        var hue = (hueBase + i * 72) % 360;
        var lightness = 50 + Math.sin(elapsed * 0.36 + i) * 15;
        swatch.style.background = 'oklch(' + lightness.toFixed(1) + '% 0.2 ' + hue.toFixed(1) + ')';
      });
    }

    function frame(now) {
      elapsed += Math.min(now - last, 100) / 1000;
      last = now;
      paint();
      raf = requestAnimationFrame(frame);
    }

    function update() {
      // Mouvement réduit, hors écran ou onglet masqué : couleurs figées
      var run = onScreen && !document.hidden && !reduce.matches;
      if (run && !raf) {
        last = performance.now();
        raf = requestAnimationFrame(frame);
      } else if (!run && raf) {
        cancelAnimationFrame(raf);
        raf = 0;
      }
    }

    paint();
    if ('IntersectionObserver' in window) {
      new IntersectionObserver(function(entries) {
        onScreen = entries[0].isIntersecting;
        update();
      }).observe(container);
    }
    document.addEventListener('visibilitychange', update);
    update();
  });
})();

Swarm Intelligence

Particules en essaim avec comportement émergent : cohésion, séparation et alignement.

Canvas Boids Émergent
GLITCH

Generative Glitch

Art glitch génératif : bandes décalées et effets chromatiques animés.

CSS Glitch Art
Page de l’effet →
Voir le code source
HTML
<div class="fx-0416-root">
  <div class="ai-glitch-container">
    <span class="ai-glitch-text" data-text="GLITCH">GLITCH</span>
  </div>
</div>
CSS
.fx-0416-root,
.fx-0416-root *,
.fx-0416-root *::before,
.fx-0416-root *::after {
  box-sizing: border-box
}

.fx-0416-root {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 250px;
  overflow: hidden;
  position: relative;
  background: rgb(26, 26, 36);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.ai-glitch-container {
  width: 100%;
  height: 100%;
  position: relative;
  overflow: hidden;
  display: flex;
  align-items: center;
  justify-content: center;
  background: #111;
}

.ai-glitch-text {
  font-size: 2.5rem;
  font-weight: 800;
  color: #fff;
  position: relative;
}

.ai-glitch-text::before,
.ai-glitch-text::after {
  content: attr(data-text);
  content: attr(data-text) / "";
  position: absolute;
  top: 0;
  left: 0;
  width: 100%;
  height: 100%;
}

.ai-glitch-text::before {
  animation: aiGlitch1 2s infinite linear alternate-reverse;
  clip-path: polygon(0 0, 100% 0, 100% 35%, 0 35%);
  color: #0ff;
}

.ai-glitch-text::after {
  animation: aiGlitch2 3s infinite linear alternate-reverse;
  clip-path: polygon(0 65%, 100% 65%, 100% 100%, 0 100%);
  color: #f0f;
}

@keyframes aiGlitch1 {
  0% {
    transform: translate(0);
  }

  20% {
    transform: translate(-3px, 2px);
  }

  40% {
    transform: translate(3px, -1px);
  }

  60% {
    transform: translate(-2px, -2px);
  }

  80% {
    transform: translate(2px, 1px);
  }

  100% {
    transform: translate(0);
  }
}

@keyframes aiGlitch2 {
  0% {
    transform: translate(0);
  }

  25% {
    transform: translate(2px, -2px);
  }

  50% {
    transform: translate(-3px, 1px);
  }

  75% {
    transform: translate(1px, 2px);
  }

  100% {
    transform: translate(0);
  }
}

@media (prefers-reduced-motion: reduce) {
  .ai-glitch-text::before {
    animation: none;
    transform: translate(-2px, 1px);
  }

  .ai-glitch-text::after {
    animation: none;
    transform: translate(2px, -1px);
  }
}
JavaScript
/* CSS pur — aucun JavaScript requis */

Predictive Grid Morph

Grille interactive dont les cases gonflent et s'éclairent autour de la souris.

CSS JS Grid

Deep Dream Pattern

Plasma arc-en-ciel calculé en direct : trois ondes sinus qui se croisent et changent de couleur sur tout le cadre.

Canvas Plasma Génératif
DESIGN

AI Typo Morph

Lettres qui se transforment fluidement entre différents mots avec un effet de morphing typographique.

JS Typo Morph
Page de l’effet →
Voir le code source
HTML
<div class="fx-0419-root">
  <div class="ai-typo-morph">
    <div class="ai-typo-word" data-words="DESIGN, CRÉER, FORMER, RÊVER, BÂTIR">DESIGN</div>
  </div>
</div>
CSS
.fx-0419-root,
.fx-0419-root *,
.fx-0419-root *::before,
.fx-0419-root *::after {
  box-sizing: border-box
}

.fx-0419-root {
  display: flex;
  align-items: center;
  justify-content: center;
  width: 100%;
  height: 250px;
  overflow: hidden;
  position: relative;
  background: rgb(26, 26, 36);
  color: rgb(255, 255, 255);
  font-family: sans-serif;
}

.ai-typo-morph {
  width: 100%;
  height: 100%;
  display: flex;
  align-items: center;
  justify-content: center;
}

.ai-typo-word {
  font-size: 2.5rem;
  font-weight: 800;
  background: linear-gradient(135deg, #6366f1, #a855f7, #ec4899);
  -webkit-background-clip: text;
  -webkit-text-fill-color: transparent;
  background-clip: text;
  letter-spacing: 2px;
}
JavaScript
(function() {
  // AI Typo Morph : le mot se brouille puis se recompose lettre par lettre
  // Mots : attribut data-words, séparés par des virgules (relu à chaque changement)
  var reduce = window.matchMedia('(prefers-reduced-motion: reduce)');
  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@#$%';

  document.querySelectorAll('.ai-typo-word').forEach(function(wordEl) {
    function readWords() {
      return (wordEl.getAttribute('data-words') || '').split(',')
        .map(function(w) { return w.trim(); })
        .filter(Boolean);
    }
    var currentWord = 0;
    var scramble = 0;
    var onScreen = true;
    if (!wordEl.textContent.trim()) wordEl.textContent = readWords()[0] || '';

    function morphTo(target) {
      clearInterval(scramble);
      // Mouvement réduit : le mot change d'un coup, sans brouillage
      if (reduce.matches) {
        wordEl.textContent = target;
        return;
      }
      var iterations = 0;
      scramble = setInterval(function() {
        var result = '';
        for (var i = 0; i < target.length; i++) {
          if (iterations > i * 2 || target[i] === ' ') {
            result += target[i];
          } else {
            result += chars[Math.floor(Math.random() * chars.length)];
          }
        }
        wordEl.textContent = result;
        iterations++;
        if (iterations > target.length * 2 + 5) {
          clearInterval(scramble);
          wordEl.textContent = target;
        }
      }, 50);
    }

    // Pause quand le bloc est hors écran
    if ('IntersectionObserver' in window) {
      new IntersectionObserver(function(entries) {
        onScreen = entries[0].isIntersecting;
      }).observe(wordEl);
    }

    setInterval(function() {
      var words = readWords();
      if (!onScreen || document.hidden || words.length < 2) return;
      currentWord = (currentWord + 1) % words.length;
      morphTo(words[currentWord]);
    }, 3000);
  });
})();

Mesh Distortion AI

Filet de points et de lignes qui se pince et ondule sous la souris.

Canvas Mesh Interactif

Questions fréquentes

Comment créer des metaballs en CSS ? +

Les metaballs CSS utilisent un filtre SVG avec feGaussianBlur et feColorMatrix. Placez des cercles colorés, appliquez le blur, puis le color matrix avec un seuil élevé pour fusionner les formes là où elles se chevauchent.

Comment animer un blob en CSS ? +

Utilisez border-radius avec 8 valeurs (ex: 30% 70% 70% 30% / 30% 30% 70% 70%) et animez-les avec @keyframes. Chaque frame change les valeurs pour créer un mouvement organique. Ajoutez un rotation lente pour plus de dynamisme.

Quelle est la différence entre liquid et glassmorphism ? +

Le glassmorphism crée un effet de verre dépoli (statique, translucide). Le liquid crée des formes organiques qui bougent et se déforment (dynamique, mouvement). Les deux peuvent être combines pour des effets spectaculaires.

Les animations liquid sont-elles performantes ? +

Les animations CSS (border-radius, transform) sont optimisées GPU. Les effets SVG filter (metaballs) sont plus lourds — limitez à 2-3 blobs. Pour des effets complexes, utilisez canvas avec requestAnimationFrame.

Peut-on utiliser des effets liquid sur mobile ? +

Oui, en simplifiant : réduisez le nombre de blobs, utilisez des animations CSS plutôt que canvas, et baissez la complexité des filtres SVG. Testez sur un appareil réel car les performances varient.

Catégories similaires