Une liste qui saccade au scroll, une animation qui perd des frames dès qu'un badge de notification se met à jour : le symptôme est toujours le même "ça lag", mais la cause est rarement unique. Flutter a un pipeline de rendu bien défini, et la plupart des problèmes de jank se résolvent en comprenant à quelle étape de ce pipeline le temps est perdu, plutôt qu'en ajoutant des const un peu partout en espérant que ça suffise.

Comprendre le budget de frame

Flutter vise 60 ou 120 images par seconde selon l'écran, ce qui laisse respectivement 16,6 ms ou 8,3 ms pour produire une frame complète. Ce budget se décompose en deux phases principales, visibles dans DevTools : le UI thread (build, layout, paint, construction de la scene) et le raster thread (rasterisation des calques en pixels via Skia ou Impeller). Un jank peut venir de l'un ou de l'autre, et le correctif n'est pas le même selon le cas.

Diagnostiquer avec le Performance Overlay et DevTools

Le premier réflexe est d'activer l'overlay de performance :

MaterialApp(
  showPerformanceOverlay: true,
  home: const HomePage(),
)

Les deux graphes montrent respectivement le temps UI et le temps raster par frame. Une barre rouge sur le graphe du haut indique un problème côté UI thread (trop de travail dans build(), trop de widgets reconstruits) ; une barre rouge en bas indique un problème de rasterisation (effets coûteux, saveLayer, flou, ombres).

Pour aller plus loin, DevTools (onglet Performance) permet d'enregistrer une timeline et d'activer "Track widget rebuilds", qui affiche exactement quels widgets se reconstruisent à chaque frame et combien de fois. C'est la seule façon fiable de confirmer qu'un widget se reconstruit réellement plus souvent que nécessaire, plutôt que de le supposer en lisant le code.

Cause n°1 : des rebuilds qui se propagent trop large

Le piège classique vient de setState() appelé sur un ancêtre trop haut dans l'arbre. Par défaut, setState() marque pour reconstruction le State concerné et tout son sous-arbre de build(), même si une seule ligne de texte a changé.

class ProductPage extends StatefulWidget {
  const ProductPage({super.key});
  @override
  State<ProductPage> createState() => _ProductPageState();
}

class _ProductPageState extends State<ProductPage> {
  int _likes = 0;

  @override
  Widget build(BuildContext context) {
    return Column(
      children: [
        ExpensiveProductCarousel(), // se reconstruit à chaque like
        LikeButton(
          likes: _likes,
          onTap: () => setState(() => _likes++),
        ),
      ],
    );
  }
}

À chaque tap sur "like", tout ProductPage.build() est rejoué, incluant ExpensiveProductCarousel qui n'a aucun lien avec le compteur de likes.

Le correctif : descendre l'état et isoler avec des widgets dédiés

La solution n'est pas d'ajouter du cache, mais de réduire le périmètre du setState(). Extraire la partie qui change dans son propre StatefulWidget limite la reconstruction à ce sous-arbre :

class LikeButton extends StatefulWidget {
  const LikeButton({super.key});
  @override
  State<LikeButton> createState() => _LikeButtonState();
}

class _LikeButtonState extends State<LikeButton> {
  int _likes = 0;

  @override
  Widget build(BuildContext context) {
    return IconButton(
      icon: Text('$_likes'),
      onPressed: () => setState(() => _likes++),
    );
  }
}

ExpensiveProductCarousel n'étant plus dans le même State, il ne se reconstruit plus du tout quand on like.

Cause n°2 : confondre "build" et "re-render coûteux"

Un rebuild de widget n'est pas forcément cher : Flutter distingue la reconstruction de l'objet Widget (une opération légère, de la configuration immuable) du travail réel de layout et de paint sur l'Element/RenderObject sous-jacent. Le vrai coût apparaît quand build() contient lui-même du travail lourd : un tri de liste, un calcul de formatage, une requête synchrone, ou la création d'objets volumineux à chaque frame.

// Mauvais : recalculé à chaque frame, même sans changement de données
@override
Widget build(BuildContext context) {
  final sorted = widget.items.sortedBy((i) => i.price); // coûteux si items est long
  return ListView(children: sorted.map(ItemTile.new).toList());
}

Le correctif consiste à sortir ce calcul du build() et à le mémoriser (via un provider, un late final recalculé uniquement quand la source change, ou ValueNotifier dédié), pas à "optimiser" le tri lui-même.

Cause n°3 : ListView et const mal utilisés

Pour les listes longues, utiliser ListView.builder plutôt que ListView avec une liste de widgets construite entièrement à l'avance est indispensable : .builder ne construit que les items visibles (plus une marge), alors que la version non paresseuse construit tout l'arbre d'un coup, même hors écran.

ListView.builder(
  itemCount: items.length,
  itemBuilder: (context, index) => ItemTile(item: items[index]),
)

Le constructeur const sur un widget n'a d'effet que si tous ses paramètres sont eux-mêmes constants au moment de la construction. Marquer const un widget qui reçoit un callback créé inline (onTap: () => doSomething()) ne change rien : ce callback est une nouvelle instance de closure à chaque build, donc le widget parent n'est pas réellement constant. L'intérêt réel de const apparaît surtout pour des sous-arbres statiques (icônes, textes fixes, séparateurs) que Flutter peut alors complètement ignorer lors de la reconstruction du parent.

Cause n°4 : le coût caché du raster thread

Quand le graphe du haut (UI) est propre mais que le bas (raster) montre des pics, le problème vient typiquement d'effets visuels coûteux à rasteriser : BoxShadow, BackdropFilter (flou), ClipRRect sur de grandes surfaces, opacité appliquée à un sous-arbre complexe via Opacity plutôt que directement sur les couleurs. Chacun de ces widgets force potentiellement un saveLayer côté moteur de rendu, une opération qui n'a rien à voir avec le nombre de rebuilds Dart.

// Coûteux : force une composition de calque à chaque frame animée
Opacity(
  opacity: _animation.value,
  child: HeavyWidgetTree(),
)
// Mieux : laisser le widget gérer lui-même son opacité quand c'est possible
FadeTransition(
  opacity: _animation,
  child: HeavyWidgetTree(),
)

FadeTransition évite de reconstruire HeavyWidgetTree à chaque tick d'animation, contrairement à Opacity combiné à un AnimatedBuilder mal placé.

Les limites de l'optimisation côté widget

Tous ces correctifs supposent que le problème est dans l'arbre de widgets. Si le jank apparaît uniquement sur appareil bas de gamme ou en mode release, mais jamais en debug sur un appareil puissant, il faut absolument profiler en mode --profile (jamais en debug, qui a ses propres overheads non représentatifs) et vérifier si le goulot est ailleurs : désérialisation JSON lourde sur le thread principal, décodage d'images non redimensionnées en amont, ou travail bloquant qui devrait être déporté sur un Isolate via compute().

Isoler le raster avec RepaintBoundary

Quand un widget a un coût de peinture réel et stable (un graphique complexe, une image avec des filtres), le problème n'est pas qu'il se repeint trop souvent, mais que son repaint entraîne celui de ses voisins dans la même couche de composition. RepaintBoundary force Flutter à isoler ce widget dans sa propre couche : son repaint ne déclenche plus celui du reste de l'arbre, au prix d'une couche de composition supplémentaire à gérer par le moteur de rendu.

RepaintBoundary(
  child: ComplexChart(data: liveData), // se repeint seul, isolé du reste
)

C'est un compromis mémoire contre CPU : chaque RepaintBoundary ajoute une texture GPU dédiée. En abuser sur des dizaines de petits widgets statiques peut dégrader la mémoire vidéo plus que ça n'économise de temps de peinture ; l'outil "Highlight repaints" de DevTools (icône de pinceau clignotant) montre précisément quelles zones de l'écran se repeignent réellement à chaque frame, et permet de ne poser des RepaintBoundary que là où un repaint isolé est confirmé coûteux.

Ajouter ses propres marqueurs dans la timeline

Pour des opérations métier qui ne correspondent à aucune phase standard du pipeline (parsing d'une réponse réseau, calcul d'un itinéraire, décodage d'un fichier local), l'API dart:developer permet d'ajouter des événements custom visibles directement dans la timeline de DevTools, aux côtés du build et du raster.

import 'dart:developer' as developer;

Future<void> loadDashboardData() async {
  developer.Timeline.startSync('parse-dashboard-json');
  final result = jsonDecode(rawResponse);
  developer.Timeline.finishSync();
  // ...
}

Cette instrumentation permet de voir, directement superposé aux barres UI/raster, si un jank ponctuel coïncide avec une opération métier précise plutôt que de rester sur l'hypothèse générique "le widget tree est trop lourd".

À retenir : un jank Flutter se diagnostique, il ne se devine pas. Commencer par l'overlay de performance pour savoir si le coût est côté UI ou raster, puis utiliser "Track widget rebuilds" pour confirmer quel widget reconstruit quoi et pourquoi, avant de choisir entre réduire le périmètre du setState, sortir un calcul du build(), ou remplacer un widget d'effet visuel par une alternative moins coûteuse à rasteriser.