Saltar al contenido

Psittacus

Optimización de rendimiento en juegos Flutter para mantener 60 FPS

Tema: Guías

Rendimiento de juegos en Flutter: cómo mantener 60 FPS en móviles de gama media

Cómo lograr 60 FPS estables en juegos Flutter en móviles de gama media: profiling con DevTools, Ticker, RepaintBoundary y optimización de atlas de sprites.

Escrito por Maksymilian JackowskiDesarrollador principal de videojuegos

Publicado el 16 min

En esta página

Un juego móvil que funciona con total fluidez en el dispositivo de desarrollo de gama alta puede ocultar serios problemas de arquitectura. La verdadera prueba comienza cuando ese mismo código se ejecuta en un smartphone común de gama media y las animaciones pierden fotogramas ante cada efecto de partículas o transición de pantalla. Mantener una tasa de refresco estable en Flutter requiere comprender cómo distribuye el motor el trabajo entre hilos, por qué las reconstrucciones innecesarias de widgets saturan la canalización y cómo medir las caídas de fluidez con rigor.

En Psittacus Studio desarrollamos juegos de lógica para móviles utilizando Flutter puro. Nuestro proyecto debut es Polydocu, un juego centrado en rompecabezas de sudoku. Incluso un tablero de 9x9 aparentemente estático, enriquecido con casillas animadas, pistas visuales, contadores y transiciones, puede agotar el presupuesto de fotograma en un procesador modesto si se enfoca como una aplicación corporativa estándar. Esta guía recopila nuestra experiencia práctica en perfilado y optimización para alcanzar 60 FPS estables en hardware real.

El presupuesto de fotograma: 16,6 milisegundos en la práctica

Para mantener 60 fotogramas por segundo, cada frame dispone de exactamente 16,6 milisegundos para completar el procesamiento y dibujar los píxeles. En pantallas modernas de 120 Hz, esa ventana temporal se reduce a 8,3 milisegundos. Si la aplicación no completa su trabajo a tiempo, el controlador de pantalla repite el fotograma anterior, lo que el jugador percibe como un tirón visual (conocido técnicamente como jank).

Flutter divide el proceso de renderizado en dos hilos principales:

  • Hilo UI. Ejecuta el código Dart de la aplicación: procesa los eventos táctiles, calcula la lógica del juego, construye widgets, evalúa el diseño en pantalla y produce el árbol de capas (layer tree).
  • Hilo ráster (raster thread). Toma el árbol de capas generado por el hilo UI y traduce los comandos de dibujo en instrucciones para la GPU mediante el motor gráfico Skia o Impeller.

La documentación oficial sobre rendimiento en Flutter subraya un principio fundamental: la lentitud en el hilo ráster casi siempre se debe a comandos de dibujo excesivamente costosos emitidos desde el código Dart. El paso inicial de cualquier optimización consiste en identificar con exactitud qué hilo está superando su presupuesto. Trasladar cálculos a un isolate independiente no solucionará nada si la GPU está saturada por aplicar filtros de desenfoque repetidos.

+------------------------------------------------------------+
| Total Frame Window: 16.6 ms (at 60 Hz)                     |
+------------------------------+-----------------------------+
| UI Thread: Dart execution,   | Raster Thread: GPU commands |
| layout, widget construction  | and pixel rasterization     |
+------------------------------+-----------------------------+

Ambos hilos operan de forma secuencial en cada fotograma. Si el hilo UI necesita 11 ms para la lógica y los widgets, y el hilo ráster requiere otros 9 ms para renderizar, el fotograma tardará 20 ms en completarse y perderá la sincronización, aunque ninguno de los dos hilos haya superado los 16,6 ms por separado.

Configuración del entorno de medición y DevTools

Evaluar el rendimiento de un juego en modo de depuración (debug) conduce a conclusiones erróneas. El modo debug incluye aserciones continuas, soporte para Hot Reload y compilación JIT, sacrificando intencionadamente la velocidad de ejecución para facilitar el desarrollo.

Las mediciones fiables deben realizarse siempre en modo profile sobre un teléfono físico:

# Debug mode: unoptimized, useful only during feature implementation
flutter run

# Profile mode: compiled AOT, DevTools services enabled
flutter run --profile

Para una verificación visual inmediata en la pantalla del dispositivo, Flutter incluye una superposición de rendimiento integrada:

MaterialApp(
  showPerformanceOverlay: true,
  checkerboardRasterCacheImages: true,
  home: const GameScreen(),
)

El gráfico superior muestra la carga del hilo ráster, mientras que el inferior representa el hilo UI. Las barras resaltadas en color rojo indican los fotogramas que han superado el umbral de 16,6 ms.

Para profundizar en el diagnóstico, la vista de rendimiento en Flutter DevTools proporciona tres herramientas indispensables:

  1. Gráfico de línea de tiempo (Timeline Flame Chart). Desglosa cada fotograma en fases detalladas, permitiendo ver cuánto tiempo consume la construcción de widgets, el layout y las llamadas de canvas.
  2. Estadísticas de ráster (Raster Stats). Registra el tiempo de renderizado de cada capa en la GPU, lo que ayuda a descubrir capas de fondo que consumen la mayor parte del presupuesto.
  3. Interruptores de capas (Layer Toggles). Permite desactivar en tiempo real las capas de recorte (clip), opacidad o sombras para aislar operaciones de composición costosas.

Para detectar reconstrucciones innecesarias de widgets directamente desde la terminal, activa el indicador correspondiente en la función main:

void main() {
  debugPrintRebuildDirtyWidgets = true;
  runApp(const GameApp());
}

Esta opción imprime en consola cada widget que se marca como dirty, facilitando la eliminación de reconstrucciones en cadena.

Línea de tiempo de Flutter DevTools con desglose de hilos UI y ráster

Desacoplar el bucle del juego del árbol de widgets

Un error recurrente al programar juegos en Flutter consiste en intentar controlar la animación mediante llamadas a setState dentro de un temporizador periódico:

// Problematic pattern: triggers full widget tree rebuilds every frame
Timer.periodic(const Duration(milliseconds: 16), (_) {
  setState(() {
    character.updatePosition();
  });
});

Llamar a setState 60 veces por segundo obliga al framework a comparar elementos en todo el árbol de widgets, recalcular geometrías y crear nuevas instancias. En procesadores móviles de gama media, este patrón satura con rapidez el hilo UI.

La arquitectura adecuada aísla por completo el estado del juego de la jerarquía de widgets. Se utiliza un Ticker para actualizar los modelos de dominio y un CustomPainter para plasmar los cambios directamente sobre un Canvas:

class GameRunnerState extends State<GameRunner>
    with SingleTickerProviderStateMixin {
  late final Ticker _ticker;
  Duration _previousTime = Duration.zero;
  final GameState _gameState = GameState();
  final ValueNotifier<int> _renderTrigger = ValueNotifier<int>(0);

  @override
  void initState() {
    super.initState();
    _ticker = createTicker(_onTick)..start();
  }

  void _onTick(Duration currentTime) {
    if (_previousTime == Duration.zero) {
      _previousTime = currentTime;
      return;
    }
    final double dt = (currentTime - _previousTime).inMicroseconds / 1000000.0;
    _previousTime = currentTime;

    _gameState.update(dt);
    _renderTrigger.value++;
  }

  @override
  void dispose() {
    _ticker.dispose();
    _renderTrigger.dispose();
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return CustomPaint(
      painter: BoardPainter(_gameState, _renderTrigger),
      size: Size.infinite,
    );
  }
}

El CustomPainter asociado escucha la señal de repintado y dibuja la escena sin intervenir en el árbol de widgets:

class BoardPainter extends CustomPainter {
  BoardPainter(this.state, Listenable repaint) : super(repaint: repaint);

  final GameState state;

  @override
  void paint(Canvas canvas, Size size) {
    // Avoid object allocations inside the hot paint path
    for (final entity in state.entities) {
      entity.render(canvas);
    }
  }

  @override
  bool shouldRepaint(covariant BoardPainter oldDelegate) => false;
}

Al devolver false en shouldRepaint, la operación de dibujo solo se ejecuta cuando lo solicita el objeto Listenable. El árbol de widgets permanece intacto durante toda la sesión de juego.

Para títulos que exigen dinámicas de acción con física continua, una alternativa reconocida en el ecosistema es el motor Flame. Los componentes de Flame cuentan con sus propios ciclos update(double dt) y render(Canvas canvas), aislando la simulación del sistema de layout de Flutter. Sin embargo, para juegos de tablero o ingenio como sudoku, un enfoque directo con CustomPainter proporciona control total sin dependencias añadidas.

Uso estratégico de RepaintBoundary

El widget RepaintBoundary crea una capa de renderizado independiente para su subárbol. La engine rasteriza dicho contenido en un búfer fuera de pantalla y lo conserva en caché, lo que permite reutilizar la imagen generada en fotogramas posteriores sin necesidad de volver a ejecutar los comandos de dibujo.

No obstante, cada límite consume memoria adicional y agrega un paso de composición en la GPU. Insertar límites de forma arbitraria suele degradar el rendimiento general.

RepaintBoundary resulta efectivo en dos situaciones concretas:

  1. Fondo estático bajo elementos con animación continua. El fondo se dibuja una sola vez y la GPU compone los elementos dinámicos sobre la imagen en caché sin repintar el entorno.
  2. Elemento pequeño con animaciones frecuentes dentro de una interfaz estática. El componente móvil se redibuja en su propia capa sin invalidar los contenedores circundantes.
Stack(
  children: [
    // Static background: rasterized once and cached
    const RepaintBoundary(
      child: StaticBoardBackground(),
    ),
    // Dynamic overlay: repainted every frame without dirtying the background
    RepaintBoundary(
      child: AnimatedParticleSystem(),
    ),
  ],
)

Deben evitarse los límites alrededor de casillas individuales en una cuadrícula densa o en elementos que cambian de aspecto en cada fotograma. Si un widget se modifica continuamente, la engine descarta y crea el búfer en cada tick, desperdiciando recursos de procesamiento. Conviene validar siempre el beneficio de cada límite en la pestaña Raster Stats de DevTools.

Eliminación de llamadas costosas a saveLayer

Ciertas combinaciones de widgets fuerzan a la engine a invocar internamente saveLayer. Esta rutina reserva un búfer intermedio fuera de pantalla, dibuja en él a los hijos, aplica la transparencia o el filtro solicitado y luego combina el resultado con el búfer principal. En chips gráficos de móviles asequibles, donde el ancho de banda de memoria es reducido, el uso reiterado de saveLayer provoca caídas inmediatas en los fotogramas.

Un caso habitual ocurre al animar el widget tradicional Opacity:

// Costly: allocates an offscreen buffer on every animation tick
Opacity(
  opacity: animationValue,
  child: const HeavyBoard(),
)

// Efficient: animates opacity via layer compositing without saveLayer
FadeTransition(
  opacity: animationController,
  child: const HeavyBoard(),
)

FadeTransition gestiona la opacidad directamente como una propiedad de la capa de composición, evitando la asignación de un búfer fuera de pantalla.

Además, combinar saveLayer con filtros de color o imagen puede inhabilitar la caché de ráster de Flutter, como se documenta en el reporte de incidencia 51975 de Flutter. Cuando la engine no logra calcular con exactitud el rectángulo de recorte del elemento filtrado, anula la caché de los componentes vecinos y fuerza el repintado completo de la escena.

Por este motivo, los desenfoques dinámicos basados en BackdropFilter deben restringirse a pantallas de pausa o diálogos modales. Aplicar desenfoque continuo sobre una partida activa a 60 FPS satura con facilidad las GPUs de gama media.

Optimización de texturas y atlas de sprites

La manipulación de gráficos es una causa frecuente de problemas en juegos 2D. Las dificultades se concentran en dos etapas: la decodificación de archivos y la proliferación de texturas individuales.

Decodificación a resolución de pantalla

Por defecto, Flutter decodifica las imágenes a su tamaño nativo de archivo. Cargar una textura de 2048x2048 píxeles en un espacio de 250x250 píxeles desperdicia memoria RAM y ocupa innecesariamente al hilo UI en labores de reescalado.

Indica siempre las dimensiones de destino mediante los parámetros cacheWidth o cacheHeight:

Image.asset(
  'assets/board_background.png',
  fit: BoxFit.cover,
  cacheWidth: (displayWidth * MediaQuery.of(context).devicePixelRatio).round(),
)

Según la documentación de la clase ImageCache, el límite estándar de la caché de imágenes es de 100 MB o 1000 elementos. Superar esa cuota provoca la expulsión de imágenes, lo que obliga a decodificarlas de nuevo cada vez que reaparecen en pantalla.

A bajo nivel, la función instantiateImageCodec con el parámetro targetWidth permite realizar el escalado directamente en el núcleo C++ de la engine antes de reservar memoria.

Agrupación mediante atlas de sprites

Dibujar múltiples imágenes independientes exige alternar texturas en la memoria de la GPU y genera un elevado número de llamadas de dibujo (draw calls). Unir los fotogramas y casillas en un único atlas de sprites permite procesar decenas de objetos en una única instrucción gráfica.

Flutter admite este método a través de Canvas.drawAtlas. En Flame, el mixin HasAutoBatchedChildren agrupa de manera automática los componentes que comparten textura:

class ParticleGroup extends PositionComponent with HasAutoBatchedChildren {
  // Child components referencing the same sprite atlas
  // render in a unified draw pass without texture swaps
}

En tableros formados por múltiples casillas estáticas, resulta conveniente dibujar todo el escenario en una imagen única durante la carga del nivel, en lugar de renderizar cientos de piezas independientes en cada fotograma del bucle principal.

Atlas de sprites que agrupa casillas del juego en una textura para reducir draw calls

Comparativa de motores gráficos: Impeller y Skia

El Flutter moderno incorpora Impeller como motor gráfico por defecto en iOS y versiones recientes de Android, mientras que Skia sigue operativo en configuraciones previas. La ventaja primordial de Impeller radica en la erradicación del shader jank, ya que todos los sombreadores necesarios se precompilan durante la fase de empaquetado de la aplicación.

Durante las sesiones de optimización, conviene contrastar el comportamiento del juego bajo ambos motores:

# Force Impeller backend
flutter run --profile --enable-impeller

# Run with Skia backend for comparative baseline
flutter run --profile --no-enable-impeller

Examinar los tiempos de fotograma en ambos motores permite discernir si un problema de fluidez proviene de controladores específicos del hardware o de la estructura interna del código. Estrategias similares de comprobación se detallan en la guía de resolución de jank en freeCodeCamp.

Para profundizar en la sincronización con la tasa de refresco, Andrea Bizzotto analiza Timer frente a Ticker, explicando el comportamiento de la sincronización de fotogramas bajo distintas cargas del procesador.

Medición rigurosa en dispositivos físicos

Confiar únicamente en pruebas sobre el ordenador de desarrollo o simuladores produce una falsa sensación de fluidez. Las CPUs de escritorio ocultan sin esfuerzo ineficiencias de cálculo que detendrán por completo a un procesador móvil.

Recomendaciones clave para un banco de pruebas representativo:

  • Dispositivo de referencia fijo. Emplea como base un smartphone Android de gama media con dos o tres años de antigüedad.
  • Control de temperatura. Cuando un móvil se sobrecalienta, activa la limitación térmica (thermal throttling) y reduce la frecuencia de sus núcleos. No realices mediciones justo después de cargarlo ni tras compilaciones prolongadas.
  • Nivel de batería. Por debajo del 20% de carga, los sistemas operativos activan mecanismos agresivos de ahorro energético. Realiza siempre las pruebas con más del 50% de batería.
  • Pruebas automatizadas. Automatiza las secuencias de juego evaluadas para garantizar condiciones idénticas en las comparaciones entre versiones de código.

La tasa media de fotogramas (Average FPS) suele ser engañosa. Un juego que marque una media de 58 FPS puede sufrir congelaciones de 150 ms cada pocos segundos, arruinando la experiencia del usuario. La métrica determinante reside en los percentiles 95 y 99 (p95 y p99).

La siguiente clase de apoyo monitoriza las duraciones de los fotogramas en compilaciones de perfilado:

class FrameDurationTracker {
  final List<double> _history = List<double>.filled(120, 0.0);
  int _cursor = 0;

  void recordFrame(double durationMs) {
    _history[_cursor % _history.length] = durationMs;
    _cursor++;
  }

  double calculateP95() {
    final List<double> samples = List<double>.from(_history)..sort();
    final int index = (samples.length * 0.95).floor();
    return samples[index];
  }

  bool isTargetMet() => calculateP95() <= 16.6;
}

El seguimiento regular de los percentiles permite subsanar fugas en el presupuesto de fotograma antes de publicar la versión final.

Perfilado de tiempos de renderizado de fotogramas en un móvil de gama media

Lista de verificación de rendimiento

Pautas esenciales para el desarrollo diario en Flutter:

  1. Realiza las mediciones de rendimiento exclusivamente en modo --profile sobre hardware físico de gama media.
  2. Desacopla la lógica de simulación del árbol de widgets empleando Ticker y CustomPainter.
  3. Evita instanciar objetos dentro de las rutinas update y paint. Preasigna los objetos Paint.
  4. Emplea RepaintBoundary de forma comedida: únicamente sobre fondos estáticos o elementos dinámicos aislados.
  5. Sustituye el widget animado Opacity por FadeTransition para evitar invocaciones de saveLayer.
  6. Ajusta la decodificación de gráficos al tamaño real en pantalla mediante cacheWidth y cacheHeight.
  7. Reúne los sprites vinculados en atlas de texturas para reducir las llamadas de dibujo en la GPU.
  8. Basa las conclusiones de fluidez en los percentiles p95 y p99 en lugar de promedios aritméticos.

FAQ: Preguntas frecuentes

¿Es adecuado Flutter para desarrollar juegos comerciales en 2D?

En el sector de juegos casuales en dos dimensiones, rompecabezas y títulos de cartas, Flutter ofrece un rendimiento excelente, desarrollo ágil y una interfaz sólida en iOS y Android. En producciones tridimensionales complejas o títulos con millones de partículas activas, motores especializados como Godot o Unity continúan siendo más apropiados.

¿Por qué se producen tirones la primera vez que aparece un elemento en pantalla?

Ese atasco inicial obedece por lo general a la carga demorada de archivos, a la rasterización de fuentes o a la compilación de sombreadores bajo Skia. Los recursos de audio e imagen deben prepararse durante la pantalla de inicio. En teléfonos con Impeller, el jank por compilación de sombreadores en plena partida queda completamente resuelto.

¿Aporta beneficios RepaintBoundary en listas con desplazamiento?

En vistas como ListView, Flutter incorpora de serie RepaintBoundary en cada elemento para evitar que el movimiento afecte a componentes visibles contiguos. Conviene evitar añadir límites manuales adicionales dentro de los constructores de elementos para no sobrecargar el compositor.

¿Conviene trasladar la carga de imágenes a un isolate secundario?

En la inmensa mayoría de los casos no es aconsejable. La canalización nativa de Flutter ya procesa la descompresión en hilos C++ en segundo plano. Transferir bloques de bytes entre isolates en Dart añade un coste de copia que suele superar cualquier ganancia. Es preferible reservar los isolates para cómputos lógicos intensivos, como el cálculo de rutas o la generación procedural de niveles.

¿Cómo deben adaptarse los bucles de juego a pantallas de 90 Hz y 120 Hz?

Todos los movimientos del juego deben escalarse multiplicando por el tiempo delta (dt) en lugar de asumir incrementos fijos de tiempo. Si el hardware no logra sostener de forma consistente un presupuesto de 8,3 ms por fotograma, fijar el límite en 60 FPS proporciona un ritmo de animación uniforme y más confortable.

¿Cómo localizar el widget que causa reconstrucciones repetitivas?

En modo debug, asigna el valor debugPrintRebuildDirtyWidgets = true. La consola mostrará el listado de widgets que solicitan actualizarse en cada tick, lo que permite reubicar con rapidez el estado fuera del árbol de widgets.

Fuentes y lecturas recomendadas


Descubre nuestra perspectiva sobre el desarrollo: conoce nuestra visión de diseño en nuestra aventura de sudoku Polydocu, aprende de dónde surgen las ideas para juegos y lee nuestras recomendaciones sobre accesibilidad en juegos móviles.


Escrito por Maksymilian Jackowski en Psittacus Studio, creadores de Polydocu, una aventura de sudoku para móviles.

Polydocu - una aventura de sudoku

Nueve números, una expedición por la selva, el loro Poly y cero barreras artificiales. Únete a la lista de espera y te avisaremos cuando el juego se estrene.

Unirse a la lista de espera

Un único correo en el lanzamiento, nada de spam.

Tres notas más del mismo cuaderno, seleccionadas por tema y no por algoritmos.

Todos los artículos