
Wydajność gier w Flutterze: jak utrzymać 60 FPS na telefonach średniej klasy
Jak utrzymać 60 FPS w grze Flutter na telefonach średniej klasy: profilowanie DevTools, kontrola przebudów, RepaintBoundary, atlasy sprite'ów i pomiar jank.
Opublikowano 13 min
Na tej stronie
Gra mobilna uruchomiona na flagowym telefonie deweloperskim potrafi zamaskować poważne błędy architektoniczne. Prawdziwy test zaczyna się wtedy, gdy ten sam kod trafia na popularny smartfon ze średniej półki, a animacje zaczynają gubić klatki przy każdej cząsteczce czy przejściu widoku. Utrzymanie stabilnego klatkażu we Flutterze wymaga zrozumienia, jak silnik rozdziela pracę na wątki, dlaczego zbędne przebudowy widgetów obciążają potok renderowania i jak rzetelnie mierzyć spadki płynności.
W Psittacus Studio tworzymy gry logiczne w czystym Flutterze. Nasz debiutancki projekt to Polydocu, mobilna gra skupiona wokół łamigłówek sudoku. Nawet z pozoru statyczna plansza 9x9, wzbogacona o animowane kafelki, dynamiczne podpowiedzi, przejścia widoków i liczniki, potrafi błyskawicznie wyczerpać budżet klatki na tańszym telefonie, jeśli potraktuje się ją jak zwykły interfejs aplikacji biznesowej. Ten poradnik podsumowuje nasze praktyczne wnioski z optymalizacji kodu i walki o stabilne 60 FPS na realnym sprzęcie.
Budżet klatki: 16,6 milisekundy w praktyce
Przy klatkażu 60 FPS na wyrenderowanie pojedynczej klatki przypada dokładnie 16,6 milisekundy. Na ekranach o odświeżaniu 120 Hz ten czas kurczy się do 8,3 milisekundy. Jeśli aplikacja nie zmieści się w tym oknie czasowym, wyświetlacz powtarza poprzednią klatkę, co gracz widzi jako zacięcie animacji (tzw. jank).
Flutter realizuje renderowanie na dwóch głównych wątkach:
- Wątek UI. Wykonuje kod w Darcie: obsługuje dotyk, przelicza logikę gry, buduje widgety, wyznacza układ elementów na ekranie i generuje drzewo warstw (layer tree).
- Wątek rastrowy (raster thread). Pobiera drzewo warstw i przekształca polecenia rysowania w instrukcje zrozumiałe dla GPU za pomocą silnika Skia lub Impeller.
Z oficjalnej dokumentacji profilowania Fluttera płynie podstawowy wniosek: powolna praca wątku rastrowego niemal zawsze wynika ze zbyt kosztownych poleceń rysowania zleconych w kodzie Dart. Dlatego pierwszym krokiem optymalizacji musi być ustalenie, który wątek przekracza swój limit czasu. Przenoszenie obliczeń matematycznych do osobnego izolatu nic nie da, jeśli układ graficzny dławi się wielokrotnym rozmyciem ekranu.
+------------------------------------------------------------+
| Total Frame Window: 16.6 ms (at 60 Hz) |
+------------------------------+-----------------------------+
| UI Thread: Dart execution, | Raster Thread: GPU commands |
| layout, widget construction | and pixel rasterization |
+------------------------------+-----------------------------+
Warto pamiętać, że oba wątki pracują kaskadowo dla każdej klatki. Jeśli wątek UI potrzebuje 11 ms na logikę i widgety, a wątek rastrowy kolejne 9 ms na rasteryzację, klatka zajmie łącznie 20 ms i wypadnie z budżetu, mimo że żaden z wątków z osobna nie przekroczył 16,6 ms.
Prawidłowe środowisko pomiarowe i narzędzia DevTools
Ocena płynności gry w trybie debugowania nie ma sensu. Tryb debug zawiera mechanizmy asercji, obsługę Hot Reload oraz działa w oparciu o kompilator JIT, który przedkłada wygodę pracy programisty nad optymalizację kodu.
Wszystkie rzetelne pomiary należy przeprowadzać w trybie profilowym na fizycznym telefonie:
# Debug mode: unoptimized, useful only during feature implementation
flutter run
# Profile mode: compiled AOT, DevTools services enabled
flutter run --profile
Do szybkiej weryfikacji bezpośrednio na ekranie telefonu służy wbudowany overlay wydajności:
MaterialApp(
showPerformanceOverlay: true,
checkerboardRasterCacheImages: true,
home: const GameScreen(),
)
Górny wykres monitoruje czas pracy wątku rastrowego, a dolny czas wątku UI. Czerwone słupki natychmiast wskazują klatki, które przekroczyły próg 16,6 ms.
Dokładną analizę umożliwia zakładka Performance w pakiecie Flutter DevTools. Do codziennej pracy przydają się trzy narzędzia:
- Wykres osi czasu (Timeline). Rozbija klatkę na poszczególne etapy, pokazując dokładny czas trwania fazy budowania widgetów, layoutu i poleceń canvasa.
- Statystyki rastrowe (Raster Stats). Rejestrują czas renderowania poszczególnych warstw na GPU, co pozwala od razu wykryć, czy dany element graficzny nie pochłania większości budżetu.
- Przełączniki warstw. Umożliwiają testowe wyłączanie warstw przycinania (clip), przezroczystości (opacity) oraz cieni w locie, co pozwala szybko sprawdzić, czy problem leży w kompozycji obrazu.
Aby wykryć nieplanowane przebudowy widgetów w logach, wystarczy włączyć flagę diagnostyczną w funkcji main:
void main() {
debugPrintRebuildDirtyWidgets = true;
runApp(const GameApp());
}
Flaga ta wypisuje w terminalu każdy widget oznaczany jako brudny, ułatwiając wychwycenie zbędnych odświeżeń drzewa.

Oddzielenie logiki gry od drzewa widgetów
Typowy błąd początkujących twórców gier we Flutterze polega na próbie napędzania animacji wywołaniem setState w cyklicznym timerze:
// Problematic pattern: triggers full widget tree rebuilds every frame
Timer.periodic(const Duration(milliseconds: 16), (_) {
setState(() {
character.updatePosition();
});
});
Wywołanie setState 60 razy na sekundę zmusza framework do ciągłego porównywania elementów w drzewie, przeliczania układu i tworzenia nowych instancji obiektów. Na telefonie ze średniej półki takie podejście szybko doprowadza do zadławienia wątku UI.
Właściwa architektura całkowicie rozdziela stan gry od struktury widgetów. Zamiast przebudowywać drzewo, stosujemy Ticker do aktualizacji stanu oraz CustomPainter do bezpośredniego rysowania zmian na canvasie:
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,
);
}
}
Dedykowany CustomPainter nasłuchuje sygnału odświeżenia i wykonuje wyłącznie rysowanie, nie dotykając drzewa widgetów:
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;
}
Zwrócenie false w shouldRepaint sprawia, że ponowne rysowanie jest wyzwalane wyłącznie przez przekazany obiekt Listenable. Drzewo widgetów pozostaje nienaruszone przez cały czas trwania rozgrywki.
Dla gier o wysokiej dynamice i ciągłym ruchu alternatywą w ekosystemie jest zewnętrzny silnik Flame. Komponenty Flame realizują własny cykl update(double dt) i render(Canvas canvas), co również odcina rozgrywkę od drzewa widgetów. Przy grach logicznych i planszowych, takich jak nasze sudoku, czysty CustomPainter oferuje jednak pełną kontrolę i nie wymaga wprowadzania dodatkowego frameworka.
Świadome użycie RepaintBoundary
Widget RepaintBoundary tworzy osobną warstwę renderowania dla swojego podelementu. Silnik rasteryzuje tę zawartość do bufora pozaekranowego i zachowuje go w pamięci, dzięki czemu w kolejnych klatkach może ponownie użyć gotowej bitmapy bez ponownego wywoływania metod rysujących.
Każda granica ma jednak swoją cenę: zużywa dodatkową pamięć RAM i dokłada kolejny krok kompozycji warstw na GPU. Wstawianie granic na ślepo, bez oparcia w pomiarach, często pogarsza wydajność zamiast ją poprawiać.
Zastosowanie RepaintBoundary przynosi realne zyski w dwóch sytuacjach:
- Statyczne tło pod animowanymi elementami. Tło planszy jest malowane raz, po czym GPU nakłada ruszające się elementy na zachowany bufor bez odrysowywania podłoża.
- Często animowany drobny element wewnątrz statycznego interfejsu. Ruchomy komponent odświeża się w swojej własnej warstwie, nie unieważniając otaczających go kontenerów.
Stack(
children: [
// Static background: rasterized once and cached
const RepaintBoundary(
child: StaticBoardBackground(),
),
// Dynamic overlay: repainted every frame without dirtying the background
RepaintBoundary(
child: AnimatedParticleSystem(),
),
],
)
Należy unikać owijania pojedynczych kafelków w siatce oraz elementów, które i tak zmieniają się co klatkę. Gdy element nieustannie zmienia swój stan, silnik w każdej klatce niszczy i od nowa alokuje bufor, marnując czas wątku rastrowego. Zasadność każdej granicy trzeba potwierdzić w widoku Raster Stats w DevTools.
Eliminacja kosztownych wywołań saveLayer i niepotrzebnej kompozycji
Niektóre konstrukcje widgetów zmuszają silnik do użycia metody saveLayer. Mechanizm ten alokuje tymczasowy bufor pozaekranowy, renderuje do niego podelementy, nakłada zadaną przezroczystość lub filtr, a na koniec scala wynik z głównym buforem ekranu. Na układach graficznych w telefonach budżetowych, gdzie przepustowość pamięci jest mocno ograniczona, powtarzane operacje saveLayer powodują natychmiastowe spadki płynności.
Częstym źródłem tego problemu jest animowanie standardowego widgetu 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 modyfikuje przezroczystość w warstwie kompozytora, omijając tworzenie dodatkowego bufora pozaekranowego.
Kolejnym zagrożeniem jest łączenie saveLayer z filtrami ColorFilter lub ImageFilter. Taka kombinacja potrafi wyłączyć pamięć podręczną rastru w silniku, co szczegółowo opisano w zgłoszeniu błędu Flutter 51975. Kiedy silnik nie potrafi precyzyjnie wyliczyć prostokąta przycięcia dla filtrowanej zawartości, unieważnia cache dla sąsiadujących elementów, zmuszając GPU do pełnego przerysowania sceny od zera.
Z tego samego powodu dynamiczne rozmycia za pomocą BackdropFilter należy zarezerwować dla statycznych ekranów pauzy lub okien modalnych. Stosowanie ciągłego rozmycia w tle aktywnej rozgrywki w 60 FPS błyskawicznie przeciąża budżet klatki na tańszych telefonach.
Optymalizacja dekodowania grafik i atlasy sprite’ów
Nieoptymalna obsługa grafik potrafi zdławić nawet prostą grę 2D. Kłopoty pojawiają się w dwóch miejscach: podczas dekodowania plików oraz przy nadmiernej liczbie pojedynczych tekstur.
Skalowanie podczas dekodowania
Flutter domyślnie dekoduje pliki graficzne w ich oryginalnej rozdzielczości. Wczytanie tekstury 2048x2048 pikseli do kafelka o wymiarach 250x250 pikseli marnuje pamięć operacyjną i niepotrzebnie obciąża wątek UI.
Rozmiar dekodowania należy wskazać za pomocą parametrów cacheWidth lub cacheHeight:
Image.asset(
'assets/board_background.png',
fit: BoxFit.cover,
cacheWidth: (displayWidth * MediaQuery.of(context).devicePixelRatio).round(),
)
Zgodnie ze specyfikacją klasy ImageCache, domyślny limit pamięci podręcznej obrazów wynosi 100 MB lub 1000 grafik. Przekroczenie tego limitu prowadzi do usuwania obiektów z pamięci podręcznej i ich powtórnego dekodowania przy każdym wyświetleniu na ekranie.
Przy niskopoziomowym wczytywaniu zasobów funkcja instantiateImageCodec z parametrem targetWidth pozwala na przeskalowanie obrazu bezpośrednio w silniku przed zaalokowaniem pamięci.
Łączenie sprite’ów w atlasy tekstur
Rysowanie wielu osobnych obrazków wymaga ciągłego przełączania tekstur w pamięci GPU i generuje dużą liczbę wywołań rysowania (draw calls). Zgrupowanie klatek animacji i kafelków w jeden wspólny atlas tekstur pozwala silnikowi narysować wszystkie elementy w pojedynczym wywołaniu graficznym.
W czystym Flutterze służy do tego metoda Canvas.drawAtlas. W przypadku projektów korzystających z silnika Flame podobne zadanie realizuje mixin HasAutoBatchedChildren, który automatycznie łączy elementy ze wspólną teksturą w jeden wsad rysowania:
class ParticleGroup extends PositionComponent with HasAutoBatchedChildren {
// Child components referencing the same sprite atlas
// render in a unified draw pass without texture swaps
}
Przy statycznych planszach kafelkowych warto wyrenderować całą siatkę do jednego bufora graficznego podczas wczytywania poziomu, zamiast rysować setki kafelków osobno w każdej klatce.
![]()
Silniki renderujące: Impeller a Skia
Nowoczesny Flutter korzysta z silnika Impeller na iOS oraz w nowszych wersjach Androida, podczas gdy starsze konfiguracje nadal pracują w oparciu o silnik Skia. Największą zaletą Impellera jest eliminacja zacięć kompilacji shaderów (shader jank), ponieważ wszystkie niezbędne warianty kodu cieniującego kompilowane są z wyprzedzeniem podczas budowania aplikacji.
W trakcie testów optymalizacyjnych warto porównywać działanie gry na obu silnikach:
# Force Impeller backend
flutter run --profile --enable-impeller
# Run with Skia backend for comparative baseline
flutter run --profile --no-enable-impeller
Porównanie czasów klatek na obu silnikach pozwala jednoznacznie ocenić, czy dany spadek płynności wynika ze specyfiki sterowników urządzenia, czy z błędów w kodzie gry. Praktyczne podejście do analizy takich różnic opisuje poradnik profilowania na freeCodeCamp.
Więcej o synchronizacji klatek z częstotliwością odświeżania ekranu pisze Andrea Bizzotto w artykule Timer vs Ticker, omawiając zachowanie pętli renderowania przy zmiennym obciążeniu procesora.
Uczciwy pomiar płynności na fizycznym telefonie
Testowanie gry wyłącznie na komputerze lub w emulatorze nie daje żadnej gwarancji płynności na urządzeniach końcowych. Wydajne procesory deweloperskie bez trudu maskują błędy, które zatrzymają przeciętny smartfon.
Dobre praktyki pomiarowe obejmują:
- Stałe urządzenie referencyjne. Do testów należy wykorzystywać fizyczny telefon z Androidem ze średniej półki, najlepiej sprzed dwóch lub trzech lat.
- Kontrola temperatury. Przegrzany telefon uruchamia thermal throttling, obniżając taktowanie rdzeni. Nie należy mierzyć wydajności bezpośrednio po odłączeniu telefonu od ładowarki czy po długiej kompilacji.
- Poziom naładowania baterii. Poniżej 20% naładowania systemy operacyjne przełączają się w tryby oszczędzania energii. Pomiary należy prowadzić przy stanie baterii powyżej 50%.
- Powtarzalne scenariusze. Testowane sekwencje powinny być powtarzalne, co pozwala rzetelnie porównywać czasy klatek przed wprowadzeniem zmian w kodzie i po nich.
Średnia liczba klatek na sekundę (Average FPS) jest myląca. Gra osiągająca średnio 58 FPS może co kilka sekund gubić pojedynczą klatkę na 150 ms, co gracz odczuwa jako wyraźne zacięcie. O jakości rozgrywki decydują czasy klatek na poziomie 95. i 99. percentyla (p95 i p99).
Poniższa klasa pomocnicza rejestruje czas trwania klatek podczas testów profilowych:
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;
}
Śledzenie wartości p95 podczas testów pozwala szybko wykryć wycieki budżetu klatki, zanim trafią one do wersji produkcyjnej.

Praktyczna checklista optymalizacji
Najważniejsze reguły codziennej pracy nad grami we Flutterze:
- Zawsze mierz czas wykonania w trybie
--profilena fizycznym telefonie ze średniej półki. - Rozdzielaj pętlę symulacji od drzewa widgetów przy użyciu klas
TickeriCustomPainter. - Unikaj alokacji obiektów wewnątrz metod
updateipaint. Twórz obiektyPaintz wyprzedzeniem. - Stosuj
RepaintBoundaryselektywnie: wyłącznie wokół statycznych teł lub odseparowanych dynamicznych elementów. - Zastępuj animowane widgety
OpacitykomponentemFadeTransition, eliminując zbędne wywołaniasaveLayer. - Dekoduj grafiki do rozmiaru docelowego przy użyciu właściwości
cacheWidthicacheHeight. - Łącz powiązane grafiki w atlasy tekstur, aby ograniczyć liczbę wywołań rysowania (draw calls).
- Oceniaj płynność na podstawie percentyli p95 i p99 zamiast średniej arytmetycznej klatek.
Najczęściej zadawane pytania
Czy Flutter nadaje się do tworzenia komercyjnych gier?
W segmencie gier dwuwymiarowych, tytułów logicznych, karcianych i zręcznościowych Flutter sprawdza się bardzo dobrze. Oferuje szybkie tempo prac i spójny interfejs na systemach iOS i Android. W przypadku rozbudowanych projektów trójwymiarowych lub zaawansowanych symulacji cząsteczkowych lepszym wyborem pozostają dedykowane silniki takie jak Godot czy Unity.
Dlaczego gra przycina się przy pierwszym uruchomieniu animacji?
Początkowe zacięcie wynika zazwyczaj z opóźnionego ładowania zasobów, rasteryzacji fontów lub kompilacji shaderów pod silnikiem Skia. Zasoby graficzne i dźwiękowe należy wczytać na ekranie startowym gry. Na urządzeniach z silnikiem Impeller problem kompilacji shaderów w trakcie rozgrywki został całkowicie wyeliminowany.
Czy RepaintBoundary pomaga w przewijanych listach?
W komponentach takich jak ListView mechanizm RepaintBoundary jest stosowany automatycznie dla każdego elementu, co chroni widoczne pozycje przed niepotrzebnym odświeżaniem. Nie należy dodawać kolejnych ręcznych granic wewnątrz kreatora elementów, gdyż mnożenie warstw obciąża kompozytor GPU.
Czy wczytywanie grafik powinno odbywać się w osobnym izolacie?
W większości przypadków nie ma takiej potrzeby. Wewnętrzny potok dekodowania obrazów we Flutterze oddelegowuje dekompresję do wątków silnika w C++. Kopiowanie surowych tablic bajtów między izolatami generuje narzut, który przewyższa potencjalne zyski. Izolaty warto zarezerwować dla ciężkich obliczeń logicznych, takich jak generowanie map czy algorytmy wyszukiwania ścieżek.
Jak dostosować pętlę gry do ekranów 90 Hz i 120 Hz?
Wszystkie przesunięcia obiektów w świecie gry muszą być skalowane przez czas delta (dt), a nie stały krok czasowy. Jeżeli budżet obliczeń na danym urządzeniu uniemożliwia stabilne osiągnięcie 8,3 ms na klatkę, bezpieczniejszym rozwiązaniem jest zablokowanie klatkażu na poziomie 60 FPS, co gwarantuje równy rytm animacji.
Jak zlokalizować widget powodujący niepotrzebne przebudowy?
W trybie debugowania należy ustawić wartość debugPrintRebuildDirtyWidgets = true. Konsola wyświetli listę wszystkich widgetów zgłaszających konieczność odświeżenia w każdej klatce. Pozwala to szybko zidentyfikować komponenty wymagające przeniesienia stanu poza drzewo widgetów.
Źródła i materiały referencyjne
- Dokumentacja profilowania wydajności Flutter - Szczegółowy opis modelu wątków i wbudowanego overlayu.
- Przewodnik po zakładce Performance w DevTools - Instrukcja analizy osi czasu, warstw graficznych i zdarzeń systemowych.
- Architektura silnika Impeller - Opis działania prekompilowanych shaderów i sprzętowej akceleracji.
- Batching grafik w silniku Flame - Wykorzystanie atlasów tekstur i mechanizmu
HasAutoBatchedChildren. - Dokumentacja ImageCache w API Fluttera - Zarządzanie pamięcią podręczną dekodowanych obrazów.
- Specyfikacja instantiateImageCodec - Niskopoziomowe dekodowanie plików z określeniem wymiarów docelowych.
- Analiza Timer vs Ticker autorstwa Andrei Bizzotto - Porównanie mechanizmów odmierzania czasu klatek.
- Praktyczny poradnik profilowania na freeCodeCamp - Rozwiązywanie realnych problemów z płynnością interfejsu.
- Zgłoszenie błędu 51975 w repozytorium Flutter - Wpływ wywołań
saveLayerz filtrami na unieważnianie pamięci podręcznej rastru.
Poznaj nasze podejście do tworzenia gier: sprawdź, jak zaprojektowaliśmy naszą przygodę sudoku Polydocu, zobacz, skąd biorą się pomysły na gry, oraz przeczytaj, jak realizujemy dostępność gier mobilnych w praktyce.
Artykuł przygotował Maksymilian Jackowski z Psittacus Studio, twórców Polydocu, przygodowej gry sudoku.
Polydocu - sudoku w formie przygody
Dziewięć cyfr, wyprawa przez dżunglę, papuga Poly i brak sztucznych blokad. Zapisz się na listę oczekujących, a wyślemy Ci powiadomienie o premierze.
Jeden e-mail przy premierze, bez spamu.




