
Flutter Spiel-Performance: 60 FPS auf Mittelklasse-Smartphones
So erreichst du stabile 60 FPS in Flutter-Spielen auf Mittelklasse-Smartphones: DevTools-Profiling, Ticker-Pfade, RepaintBoundary und Sprite-Atlanten.
Veröffentlicht am 13 Min.
Auf dieser Seite
Ein Handyspiel, das auf einem modernen Entwickler-Smartphone flüssig läuft, kann gravierende architektonische Engpässe leicht verbergen. Der eigentliche Praxistest beginnt, wenn derselbe Code auf einem gewöhnlichen Mittelklasse-Smartphone ausgeführt wird und Animationen bei jedem Partikeleffekt oder Bildschirmwechsel ins Stocken geraten. Eine stabile Rendering-Leistung in Flutter erfordert ein klares Verständnis davon, wie die Engine die Arbeit auf Threads verteilt, warum unnötige Widget-Rebuilds die Pipeline ausbremsen und wie man Ruckler (Jank) verlässlich misst.
Bei Psittacus Studio entwickeln wir mobile Logikspiele in reinem Flutter. Unser Debütprojekt Polydocu ist ein Sudoku-Abenteuer für mobile Geräte. Selbst ein scheinbar statisches 9x9-Gitter, kombiniert mit animierten Zahlenfeldern, dynamischen Hinweisen, Bildschirmübergängen und Zählern, kann das Frame-Budget auf günstigerer Hardware schnell sprengen, wenn man das Spiel wie eine gewöhnliche Formular-App aufbaut. Dieser Leitfaden fasst unsere praktischen Erfahrungen aus der Profilierung und Optimierung von Flutter-Spielen auf realer Hardware zusammen.
Das Frame-Budget: 16,6 Millisekunden in der Praxis
Um stabile 60 Bilder pro Sekunde zu halten, stehen für jeden Frame genau 16,6 Millisekunden zur Verfügung. Auf modernen 120-Hz-Displays schrumpft dieses Zeitfenster auf 8,3 Millisekunden. Kann die Anwendung diesen Zeitraum nicht einhalten, wiederholt der Display-Controller das vorherige Bild. Spieler nehmen das sofort als störendes Ruckeln wahr.
Flutter verteilt das Rendern auf zwei zentrale Threads:
- UI-Thread. Führt den Dart-Code aus: verarbeitet Touch-Eingaben, berechnet die Spiellogik, baut Widgets, kalkuliert das Layout und erzeugt den Layer-Tree.
- Raster-Thread. Liest den vom UI-Thread gelieferten Layer-Tree und wandelt die Zeichenbefehle über die Grafik-Engine (Skia oder Impeller) in GPU-Instruktionen um.
Aus der offiziellen Performance-Dokumentation von Flutter geht ein wesentlicher Grundsatz hervor: Engpässe auf dem Raster-Thread entstehen fast ausnahmslos durch zu teure Zeichenbefehle, die im Dart-Code ausgelöst wurden. Der erste Schritt jeder Optimierung besteht daher darin, exakt festzustellen, welcher Thread das Zeitbudget überschreitet. Reine Mathematik in einen Hintergrund-Isolate auszulagern nützt nichts, wenn die GPU durch wiederholte Weichzeichner überlastet ist.
+------------------------------------------------------------+
| Total Frame Window: 16.6 ms (at 60 Hz) |
+------------------------------+-----------------------------+
| UI Thread: Dart execution, | Raster Thread: GPU commands |
| layout, widget construction | and pixel rasterization |
+------------------------------+-----------------------------+
Beide Threads arbeiten pro Frame nacheinander. Wenn der UI-Thread 11 ms für Logik und Widgets benötigt und der Raster-Thread weitere 9 ms für das Zeichnen aufwendet, dauert der Frame insgesamt 20 ms und verpasst die Deadline, obwohl keiner der Threads für sich allein 16,6 ms überschritten hat.
Zuverlässige Profilierung mit DevTools
Ein Spiel im Debug-Modus auf Leistung zu testen, führt zu völlig falschen Schlüssen. Der Debug-Modus enthält assertions, Hot-Reload-Code und JIT-Kompilierung, wodurch Laufzeitgeschwindigkeit bewusst zugunsten des Entwicklungskomforts geopfert wird.
Benchmarks müssen ausnahmslos im Profile-Modus auf einem physischen Testgerät durchgeführt werden:
# Debug mode: unoptimized, useful only during feature implementation
flutter run
# Profile mode: compiled AOT, DevTools services enabled
flutter run --profile
Für eine schnelle Sichtprüfung direkt auf dem Bildschirm bietet Flutter ein integriertes Performance-Overlay:
MaterialApp(
showPerformanceOverlay: true,
checkerboardRasterCacheImages: true,
home: const GameScreen(),
)
Der obere Graph visualisiert die Auslastung des Raster-Threads, der untere die des UI-Threads. Rote Balken markieren Frames, die länger als 16,6 ms gedauert haben.
Zur detaillierten Analyse dient die Performance-Ansicht in Flutter DevTools. Drei Werkzeuge sind für die tägliche Arbeit entscheidend:
- Timeline Flame Chart. Zerlegt jeden Frame in seine Phasen und zeigt exakt, wie lange Widget-Builds, Layout-Berechnungen und Zeichenaufrufe dauerten.
- Raster Stats. Zeigt die Rasterisierungszeit einzelner Layer auf der GPU, sodass teure Hintergründe sofort auffallen.
- Layer Toggles. Erlaubt das temporäre Deaktivieren von Clip-, Opacity- und Schatten-Layern zur Laufzeit, um teure Compositing-Schritte zu isolieren.
Um ungewollte Widget-Rebuilds über das Terminal aufzuspüren, genügt ein Schalter in der main-Methode:
void main() {
debugPrintRebuildDirtyWidgets = true;
runApp(const GameApp());
}
Ist diese Option aktiv, gibt die Konsole jedes Widget aus, das als verändert markiert wird, was das Bereinigen unnötiger Rebuild-Ketten deutlich erleichtert.

Entkopplung der Game Loop vom Widget-Baum
Der häufigste Architekturfehler in Flutter-Spielen ist der Versuch, kontinuierliche Bewegungen über setState in einem zyklischen Timer zu steuern:
// Problematic pattern: triggers full widget tree rebuilds every frame
Timer.periodic(const Duration(milliseconds: 16), (_) {
setState(() {
character.updatePosition();
});
});
Ein sechzigmaliges Aufrufen von setState pro Sekunde zwingt das Framework dazu, Elemente im Widget-Baum abzugleichen, Layouts neu zu berechnen und neue Widget-Instanzen anzulegen. Auf Mittelklasse-Prozessoren bringt dieser Ansatz den UI-Thread schnell an seine Leistungsgrenze.
Die saubere Lösung trennt den Spielzustand vollständig von der Widget-Hierarchie. Ein Ticker aktualisiert die Spiellogik, während ein CustomPainter die Änderungen direkt auf einer Canvas zeichnet:
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,
);
}
}
Der zugehörige CustomPainter lauscht auf das Repaint-Signal und zeichnet die Szene neu, ohne den Widget-Baum zu belasten:
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;
}
Weil shouldRepaint den Wert false zurückgibt, wird das Neuzeichnen ausschließlich durch das übergebene Listenable angestoßen. Der Widget-Baum bleibt während der laufenden Spielrunde unberührt.
Für actionreiche Spiele mit kontinuierlicher Physik bietet sich als etablierte Alternative die Flame-Engine an. Komponenten in Flame besitzen eigene update(double dt)- und render(Canvas canvas)-Zyklen und umgehen das Layout-System von Flutter standardmäßig. Für gitterbasierte Denk- und Rätselspiele wie Sudoku bietet ein reiner CustomPainter jedoch maximale Kontrolle ohne zusätzliche Paketabhängigkeiten.
Gezielter Einsatz von RepaintBoundary
Das Widget RepaintBoundary erstellt einen separaten Render-Layer für seinen Unterbaum. Die Engine rastert diesen Bereich in einen Offscreen-Puffer und behält ihn im Speicher, sodass nachfolgende Frames auf das fertige Pixelbild zugreifen können, solange sich der Inhalt nicht ändert.
Jede Grenze verursacht jedoch Speicheraufwand und erfordert einen zusätzlichen Compositing-Schritt auf der GPU. Werden Grenzen willkürlich gesetzt, sinkt die Bildrate oft ab.
Der Einsatz von RepaintBoundary lohnt sich in zwei klaren Fällen:
- Statischer Hintergrund unter bewegten Objekten. Das Spielfeld wird einmal gezeichnet, und die GPU platziert bewegte Elemente auf den bestehenden Puffer, ohne den Hintergrund neu zu berechnen.
- Kleine, häufig animierte Elemente innerhalb einer statischen Oberfläche. Das animierte Element zeichnet sich in seinem eigenen Puffer neu, ohne umliegende Container zu invalidieren.
Stack(
children: [
// Static background: rasterized once and cached
const RepaintBoundary(
child: StaticBoardBackground(),
),
// Dynamic overlay: repainted every frame without dirtying the background
RepaintBoundary(
child: AnimatedParticleSystem(),
),
],
)
Einzelne Kacheln in einem dichten Gitter oder Widgets, die sich ohnehin in jedem Frame verändern, sollten nicht mit einer Grenze umhüllt werden. Ändert sich der Inhalt ständig, muss die Engine den Layer-Puffer in jedem Frame verwerfen und neu erzeugen. Überprüfe jede gesetzte Grenze stets in den Raster Stats der DevTools.
Vermeidung teurer saveLayer-Aufrufe
Manche Widget-Kombinationen zwingen die Engine zum Aufruf von saveLayer. Dieser Mechanismus erzeugt einen temporären Zwischenpuffer, rendert die Kindelemente hinein, wendet Transparenzen oder Filter an und fügt das Ergebnis wieder mit dem Hauptbildschirm zusammen. Auf mobilen GPUs mit begrenzter Speicherbandbreite führen wiederholte saveLayer-Aufrufe zu deutlichen Performance-Einbrüchen.
Eine häufige Ursache ist das Animieren des normalen Opacity-Widgets:
// 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 passt die Deckkraft direkt als Eigenschaft des Compositor-Layers an und vermeidet so die Erzeugung zusätzlicher Offscreen-Puffer.
Wird saveLayer zudem mit ColorFilter oder ImageFilter kombiniert, kann dies den internen Bild-Raster-Cache von Flutter deaktivieren, wie in Flutter Issue 51975 dokumentiert ist. Wenn die Engine das Zuschnittsrechteck nicht exakt bestimmen kann, schaltet sie das Caching für umliegende Inhalte ab und zwingt das System zum vollständigen Neuzeichnen.
Aus diesem Grund sollten dynamische Unschärfe-Effekte mit BackdropFilter nur auf Standbildern oder Pausenmenüs eingesetzt werden. Dynamischer Blur über laufendem 60-FPS-Gameplay überlastet Mittelklasse-GPUs fast immer.
Textur-Optimierung und Sprite-Atlanten
Die Verarbeitung von Grafiken ist bei mobilen 2D-Spielen eine typische Rucklerquelle. Engpässe entstehen beim Dekodieren der Dateien sowie bei einer zu hohen Anzahl einzelner Texturen.
Skalierung beim Dekodieren
Standardmäßig dekodiert Flutter Bilddateien in ihrer nativen Auflösung. Eine 2048x2048-Textur in ein 250x250-Feld zu laden, verschwendet Arbeitsspeicher und belastet den UI-Thread unnötig mit Skalierungsberechnungen.
Definiere die Zielauflösung über die Parameter cacheWidth oder cacheHeight:
Image.asset(
'assets/board_background.png',
fit: BoxFit.cover,
cacheWidth: (displayWidth * MediaQuery.of(context).devicePixelRatio).round(),
)
Laut Dokumentation der ImageCache-Klasse liegt das Standardlimit bei 100 MB oder 1000 Bildern. Wird dieser Schwellenwert überschritten, werden Bilder aus dem Speicher entfernt und beim nächsten Erscheinen erneut von Grund auf dekodiert.
Auf niedrigerer Ebene erlaubt die Funktion instantiateImageCodec mit dem Parameter targetWidth, die Skalierung direkt im C++-Kern der Engine vorzunehmen, bevor RAM alloziert wird.
Bündelung über Sprite-Atlanten
Viele separate Grafiken erfordern fortwährende Texturwechsel im GPU-Speicher und erzeugen zahlreiche Draw Calls. Durch das Zusammenfassen einzelner Sprites in einen gemeinsamen Sprite-Atlas kann die Engine hunderte Elemente in einem einzigen Zeichenaufruf abarbeiten.
Flutter unterstützt dies über Canvas.drawAtlas. In Flame übernimmt der Mixin HasAutoBatchedChildren die automatische Bündelung von Komponenten mit geteiltem Atlas:
class ParticleGroup extends PositionComponent with HasAutoBatchedChildren {
// Child components referencing the same sprite atlas
// render in a unified draw pass without texture swaps
}
Bei statischen Kachelfeldern lohnt es sich zudem, die gesamte Karte beim Laden des Levels einmalig in ein Offscreen-Bild zu zeichnen, anstatt im laufenden Spiel Frame für Frame hunderte Kacheln einzeln zu rendern.
![]()
Grafik-Engines im Vergleich: Impeller und Skia
Modernes Flutter verwendet Impeller auf iOS sowie auf neueren Android-Versionen, während ältere Systeme auf Skia zurückgreifen. Der größte Vorteil von Impeller liegt in der Beseitigung von Shader-Kompilierungsrucklern, da sämtliche Shader-Varianten bereits beim Bauen der Anwendung vorkompiliert werden.
Bei Performancetests empfiehlt es sich, das Verhalten unter beiden Engines zu vergleichen:
# Force Impeller backend
flutter run --profile --enable-impeller
# Run with Skia backend for comparative baseline
flutter run --profile --no-enable-impeller
Ein Vergleich der Frame-Zeiten auf beiden Engines zeigt verlässlich, ob ein Leistungseinbruch auf Treibereigenheiten des Geräts oder auf Probleme im eigenen Spielcode zurückzuführen ist. Weitere praxisnahe Profilierungsschritte beschreibt der Leitfaden zur Jank-Behebung auf freeCodeCamp.
Details zur Synchronisation mit der Bildwiederholrate erläutert Andrea Bizzotto im Artikel Timer vs Ticker, in dem das Verhalten von Ticker-Callbacks unter wechselnder Systemlast analysiert wird.
Praxismessungen auf physischen Smartphones
Messungen auf dem Entwicklerrechner oder im Simulator bieten keine verlässliche Grundlage für die mobile Realität. Leistungsstarke Desktop-CPUs kaschieren selbst schwere Ineffizienzen, die ein Smartphone sofort zum Stillstand bringen.
Wichtige Regeln für aussagekräftige Benchmarks:
- Feste Referenzgeräte. Verwende als Haupttestgerät ein Mittelklasse-Android-Smartphone, das zwei bis drei Jahre alt ist.
- Temperaturkontrolle. Bei Überhitzung drosseln mobile Prozessoren automatisch den Takt (Thermal Throttling). Führe keine Tests direkt nach dem Ladevorgang oder nach langen Kompiliervorgängen durch.
- Akkustand beachten. Bei einem Ladestand unter 20% aktivieren viele Smartphones aggressive Stromsparmodi. Führe Performancemessungen daher stets bei über 50% Akkustand durch.
- Wiederholbare Szenarien. Steuere Spielabläufe über automatisierte Skripte, um identische Bedingungen für Vorher-Nachher-Vergleiche sicherzustellen.
Die durchschnittliche Bildrate (Average FPS) ist trügerisch. Ein Spiel mit durchschnittlich 58 FPS kann alle paar Sekunden für 150 ms hängen bleiben, was das Spielerlebnis zerstört. Entscheidend sind die 95.- und 99.-Perzentilwerte (p95 und p99).
Folgende Hilfsklasse zeichnet Frame-Dauern in Profil-Builds auf:
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;
}
Die kontinuierliche Überwachung von Perzentilen sorgt dafür, dass Performance-Probleme frühzeitig behoben werden können.

Checkliste für den Entwicklungsalltag
Wichtige Grundregeln für stabile Bildraten in Flutter-Spielen:
- Führe Performancetests ausnahmslos im Modus
--profileauf physischer Mittelklasse-Hardware durch. - Trenne die Spielschleife über
TickerundCustomPaintervollständig vom Widget-Baum. - Vermeide Objekterzeugungen in den Methoden
updateundpaint. HaltePaint-Objekte im Speicher vor. - Setze
RepaintBoundarysparsam ein: nur für statische Hintergründe oder isolierte dynamische Komponenten. - Ersetze animierte
Opacity-Widgets durchFadeTransition, um überflüssigesaveLayer-Aufrufe zu verhindern. - Dekodiere Bilder über
cacheWidthundcacheHeightpassgenau auf Zielgröße. - Fasse zusammengehörige Sprites in Atlanten zusammen, um Draw Calls auf der GPU zu minimieren.
- Beurteile die Performance anhand von p95- und p99-Perzentilen statt über Durchschnittswerte.
FAQ: Häufig gestellte Fragen
Eignet sich Flutter für kommerzielle 2D-Spiele?
Für 2D-Gelegenheitsspiele, Denk- und Kartenspiele bietet Flutter hervorragende Performance, schnelle Entwicklungszyklen und eine einheitliche UI auf iOS und Android. Für komplexe 3D-Titel oder extrem aufwendige Partikelsimulationen eignen sich spezialisierte Engines wie Godot oder Unity weiterhin besser.
Warum ruckelt das Spiel beim ersten Anzeigen neuer Elemente?
Ursache dafür sind meist verzögertes Nachladen von Assets, Font-Rasterisierung oder Shader-Kompilierung unter Skia. Grafiken und Sounds sollten daher im Ladebildschirm initialisiert werden. Auf Geräten mit Impeller entfällt das Shader-Ruckeln zur Laufzeit vollständig.
Verbessert RepaintBoundary die Leistung in scrollbaren Listen?
In Listen wie ListView wird RepaintBoundary standardmäßig um Listenelemente gesetzt, damit verdeckte Einträge sichtbare Bereiche nicht invalidieren. Manuelle zusätzliche Grenzen innerhalb von Item-Buildern sollten vermieden werden, um den Compositor nicht mit unnötigen Layern zu überlasten.
Sollte das Laden von Bildern in separate Isolates ausgelagert werden?
Im Regelfall nicht. Die Dekodierung in Flutter wird intern bereits an native Hintergrund-Threads der Engine delegiert. Das Kopieren von Byte-Arrays zwischen Dart-Isolates verursacht oft mehr Overhead als Nutzen. Isolates eignen sich vor allem für rechenintensive Logik wie Pfadfindung oder Kartengenerierung.
Wie geht man mit 90-Hz- und 120-Hz-Displays um?
Alle Bewegungen müssen über die Delta-Zeit (dt) skaliert werden statt über feste Frame-Schritte. Reicht die Hardware-Leistung nicht stabil für 8,3 ms pro Frame aus, sorgt eine feste Begrenzung auf 60 FPS für einen gleichmäßigen Rhythmus.
Wie findet man Widgets, die sich unerwünscht oft neu aufbauen?
Im Debug-Modus setzt man debugPrintRebuildDirtyWidgets = true. Die Konsole listet daraufhin jedes Widget auf, das in einem Frame neu aufgebaut wird. So lassen sich dynamische Werte schnell vom statischen UI-Teil trennen.
Quellen und weiterführende Literatur
- Flutter UI Performance Dokumentation - Übersicht über das Thread-Modell und das Performance-Overlay.
- DevTools Performance View Leitfaden - Anleitung zur Analyse von Timeline-Events und Raster-Statistiken.
- Impeller Rendering Engine Architektur - Funktionsweise vorkompilierter Shader und Hardware-Beschleunigung.
- Sprite-Batching in der Flame-Engine - Verwendung von Textur-Atlanten und
HasAutoBatchedChildren. - ImageCache API-Referenz - Verwaltung des Bildspeichers in Flutter.
- instantiateImageCodec Spezifikation - Low-Level-Dekodierung von Grafiken mit Zielgrößen.
- Andrea Bizzotto über Timer vs Ticker - Vergleich der Methoden zur Frame-Taktung.
- Praktischer Performance-Leitfaden auf freeCodeCamp - Fehlerbehebung bei Rendering-Problemen in der Praxis.
- Flutter Engine Issue 51975 - Auswirkung von
saveLayermit Bildfiltern auf den Raster-Cache.
Einblicke in unsere Spieleentwicklung: Erfahre mehr über unsere Designphilosophie in unserem Sudoku-Abenteuer Polydocu, entdecke, woher Spielideen kommen, und lies über unsere Ansätze für Barrierefreiheit in mobilen Spielen.
Verfasst von Maksymilian Jackowski bei Psittacus Studio, den Entwicklern von Polydocu, einem mobilen Sudoku-Abenteuer.
Polydocu - ein Sudoku-Abenteuer
Neun Ziffern, eine Expedition durch den Dschungel, Papagei Poly und keine künstlichen Hürden. Tragen Sie sich in die Warteliste ein und wir benachrichtigen Sie zum Start des Spiels.
Eine E-Mail zum Start, kein Spam.




