
Spielstand in Flutter speichern: shared_preferences vs Hive vs Isar vs SQLite
Spielstände in Flutter sicher speichern, ohne Fortschritte zu verlieren: Vergleich von shared_preferences, Hive, Isar und SQLite, mit Schema-Migration.
Veröffentlicht am 13 Min.
Auf dieser Seite
Am Sonntagmorgen öffnest du dein Postfach und liest die Nachricht eines frustrierten Spielers. Nach dem gestrigen Update deines Sudoku-Spiels ist seine 214-Tage-Serie spurlos verschwunden. Das Rätsel, das er zur Hälfte gelöst hatte, ist wieder vollkommen leer.
Ein Blick in den Code offenbart die Ursache schnell: Die Speicherdatei enthielt keine Versionsnummer. Das neue Release erwartete eine leicht veränderte Datenstruktur, weshalb der Lader beim Parsen unerwarteter Felder stillschweigend null zurückgab. Technisch gesehen wurden die Daten nicht von der Festplatte gelöscht, sondern waren für die neue Version schlicht unlesbar. Für den Spieler macht dieser Unterschied jedoch keinen Unterschied: Sein monatelanger Spielfortschritt ist verloren.
Das Verwalten von Spielständen in Flutter (im Englischen oft als flutter game save data gesucht) wirkt auf den ersten Blick trivial. Diese Illusion platzt jedoch in dem Moment, in dem ein unbedachtes Update echte Nutzerdaten beschädigt. In diesem Leitfaden vergleichen wir die vier gängigsten Speicherlösungen in Flutter: shared_preferences, Hive, Isar und SQLite. Wir zeigen dir, welche Daten auf die Festplatte gehören, was du weglassen solltest und wie du ein praxiserprobtes Save-Envelope-Muster mit reinen Vorwärtsmigrationen implementierst. Alle Codebeispiele sind in reinem Dart geschrieben, sodass du sie direkt in DartPad ausprobieren kannst.
Warum persistenter Fortschritt ein Kernfeature ist
In vielen Entwickler-Tutorials wird die Datenhaltung stiefmütterlich behandelt: ein schneller Zwischenschritt zwischen dem Layout des Spielfelds und der Veröffentlichung im Store. Für Spieler ist die Beständigkeit ihrer Spielstände jedoch ein zentrales Versprechen. Logik- und Puzzlespiele wie Sudoku leben von Kontinuität: das halbfertige Rätsel auf dem Weg zur Arbeit, die tägliche Siegesserie und Statistiken, die über Monate hinweg gesammelt wurden. Verliert ein Spieler diesen Fortschritt nach einem Update, fühlt er sich betrogen. Statt von vorne anzufangen, deinstalliert er das Spiel meist sofort.
Die Zuverlässigkeit der Speicherung entscheidet maßgeblich über die langfristige Nutzerbindung (Retention). Spieler kehren nur dann verlässlich zurück, wenn sie die App jederzeit schließen oder sperren können, ohne ihre Züge zu verlieren. Wenn das Verlassen der App mitten in einer Partie zum Glücksspiel wird, öffnen Nutzer das Spiel in kurzen Pausen gar nicht erst. Ein solides, verlässliches Speichersystem ist eine der günstigsten und effektivsten Maßnahmen für hohe Spielerbindung.
Die vier Speicheroptionen in Flutter
In der Praxis decken vier Werkzeuge fast jeden Speicherbedarf in Flutter ab. Jedes dieser Tools besitzt klare Stärken, bringt aber auch spezifische Kompromisse mit sich.
shared_preferences ist das offizielle Key-Value-Plugin des Flutter-Teams. Es kapselt plattformspezifische Speicher: NSUserDefaults unter iOS und macOS, Android SharedPreferences oder das modernere DataStore Preferences. Es unterstützt einfache Datentypen wie int, double, bool, String und List<String>. Seit Version 2.3.0 stellt das Paket mit SharedPreferencesAsync und SharedPreferencesWithCache zwei moderne APIs bereit, während die alte Klasse SharedPreferences als veraltet gilt. Für Lautstärkepegel, Themes oder einfache Flags ist es hervorragend geeignet, für den eigentlichen Spielstand jedoch die falsche Wahl.
Hive ist eine schlanke, in reinem Dart geschriebene Key-Value-Datenbank, inspiriert von Bitcask. Daten werden in sogenannten Boxes gespeichert, die typisiert oder dynamisch sein können. Sobald eine Box geöffnet ist, erfolgen Lesezugriffe synchron direkt aus dem Arbeitsspeicher, was blitzschnelle Reaktionszeiten liefert. Da der ursprüngliche Autor die Weiterentwicklung abgegeben hat, wird das Projekt von der Community aktiv als hive_ce-Fork gepflegt. Hive ist eine ausgezeichnete Wahl für kleine bis mittelgroße Puzzlespiele mit strukturierter Datenablage.
Isar ist eine moderne NoSQL-Datenbank desselben Entwicklers. Sie bietet komplexe Abfragen, Indizes, Objektverknüpfungen und volle ACID-Transaktionssicherheit. Version 3 ist stabil und praxiserprobt. Die Entwicklung von Isar 4 zieht sich jedoch bereits über einen langen Zeitraum hin. Bevor du Isar für ein neues kommerzielles Projekt wählst, solltest du die Aktivität im Isar-GitHub-Repository und offene Issues prüfen, um zu sehen, ob das Entwicklungstempo zu deinen Anforderungen passt.
SQLite, in Flutter meist über das Plugin sqflite oder die typsichere Abstraktion drift genutzt, ist der bewährte relationale Standard. Die Engine garantiert volle ACID-Konformität, jahrzehntelange Stabilität und unterstützt den WAL-Modus (Write-Ahead Logging) für schnelle, parallele Lesezugriffe. SQLite skaliert mühelos von einer simplen Einstellungstabelle bis hin zu Tausenden archivierten Sudoku-Partien samt Zug-für-Zug-Historie. Der Preis dafür ist höherer Initialaufwand für Schemadateien, SQL-Abfragen und Tabellenmigrationen.
Vergleich der Technologien
| Werkzeug | Einrichtungsaufwand | Lese- und Schreibtempo | Optimale Datengröße | Bester Einsatzzweck |
|---|---|---|---|---|
| shared_preferences | Sehr gering | Schnell für Einzelwerte | Bis wenige Kilobyte | Audioeinstellungen, Dark Mode, Tutorial-Flags |
| Hive | Gering | Extrem schnell (im RAM) | Bis wenige Megabyte je Box | Hauptspielstand für Casual- und Puzzlespiele |
| Isar | Mittel | Schnell mit Indizes | Megabyte bis Dutzende MB | Komplexe Modelle mit Relationen und Filtern |
| SQLite (sqflite / drift) | Mittel bis hoch | Hohe Stabilität, ACID, WAL | Beliebig bei passenden Indizes | Spielhistorie, Zugarchive, detaillierte Statistiken |

Entscheide dich immer anhand deines Worst-Case-Szenarios, nicht anhand des Startzustands. Ein einzelnes Sudoku-Feld benötigt kaum ein Kilobyte. Wenn ein treuer Nutzer jedoch nach einem Jahr tausend gelöste Rätsel samt Antwortzeiten für jede Zelle gespeichert hat, wächst die Datenmenge beträchtlich. Wähle ein Werkzeug, das auch nach Monaten intensiver Nutzung performant bleibt.
Was gespeichert werden sollte und was nicht
Der effizienteste Festplattenzugriff ist der, der gar nicht erst stattfinden muss. Bevor du Speicherlogik programmierst, solltest du genau festlegen, welche Daten wirklich dauerhaft aufbewahrt werden müssen.
Was du speichern solltest:
- Aktueller Spielzustand. Bei einem Sudoku: die Rätsel-ID, die vorgegebenen Startzahlen (oder der Generator-Seed), die Spielereingaben, Notizen und die Zuganzahl. Speichere die verstrichene Zeit als kumulierte Millisekunden (
elapsedMs) und nicht als lebendesDateTime-Objekt. So bleibt die Stoppuhr exakt, selbst wenn der Spieler Zeitzonen wechselt oder das Gerät stundenlang im Standby liegt. - Benutzereinstellungen. Lautstärke für Musik und Soundeffekte, Haptik (Vibration), gewähltes Farbschema und Schwierigkeitsgrad.
- Statistiken und Serien. Gewonnene Spiele, Durchschnittszeiten, Bestzeiten und die aktuelle Tagesserie mit dem Datum des letzten gewerteten Sieges. Ein verlässlicher Datumsanker ermöglicht die Prüfung der Serie nach einem Neustart; eine nackte Zahl wie
streak = 12bietet im Fehlerfall keinerlei Rekonstruktionsmöglichkeit. - Fortschritts-Flags. Markierungen, ob das Tutorial abgeschlossen oder die Bewertungsaufforderung bereits angezeigt wurde.
Was du nicht speichern solltest:
- Berechenbare Hilfswerte. Mögliche Kandidatenzahlen für ein Sudoku-Feld lassen sich in Mikrosekunden direkt aus dem aktuellen Spielfeld ermitteln. Sie in der Speicherdatei abzulegen, bläht die Datei unnötig auf und führt bei Algorithmen-Updates schnell zu Inkonsistenzen.
- Flüchtige UI-Zustände. Scrollpositionen von Listen, geöffnete Dialogfenster oder Animationsphasen gehören zur Präsentationsschicht, nicht zum Spielfortschritt. Sie sollten beim Starten der Ansicht dynamisch rekonstruiert werden.
- Komplette Schnappschüsse bei jeder kleinsten Berührung. Speichere den Zustand an sinnvollen Kontrollpunkten: nach einer Serie von Eingaben, beim Pausieren des Spiels oder wenn die App in den Hintergrund wechselt. Ein Sudoku-Gitter im JSON-Format ist zwar klein, aber hunderte Festplattenzugriffe pro Minute belasten Akku und Flash-Speicher unnötig.
- Ungeprüfte Systemuhren. Spieler stellen gerne die Uhrzeit ihres Smartphones um, um Wartezeiten zu umgehen. Nutze die lokale Gerätezeit nur zur Anzeige auf dem Bildschirm. Für Spiellogik, Tagesbelohnungen und Serien solltest du auf monotone Timer oder Server-Zeitstempel setzen.
Das folgende Beispiel zeigt eine saubere Datenklasse für ein Sudoku-Spiel. Alle Felder repräsentieren ausschließlich den Ausgangszustand, Nutzeraktionen oder Zähler. Der Code ist in reinem Dart geschrieben und funktioniert direkt in DartPad:
class SudokuSave {
SudokuSave({
required this.puzzleSeed,
required this.entries,
required this.pencilMarks,
required this.elapsedMs,
required this.hintsUsed,
});
factory SudokuSave.fresh(String seed) => SudokuSave(
puzzleSeed: seed,
entries: List.filled(81, 0),
pencilMarks: const {},
elapsedMs: 0,
hintsUsed: 0,
);
final String puzzleSeed; // Givens regenerate from the seed.
final List<int> entries; // 81 cells, 0 means empty.
final Map<int, Set<int>> pencilMarks;
final int elapsedMs; // Accumulated time in milliseconds.
final int hintsUsed;
Map<String, Object?> toJson() => {
'puzzleSeed': puzzleSeed,
'entries': entries,
'pencilMarks': {
for (final e in pencilMarks.entries)
'${e.key}': e.value.toList(),
},
'elapsedMs': elapsedMs,
'hintsUsed': hintsUsed,
};
}
Das Save-Envelope-Muster: Schutz vor Datenverlust
Ganz gleich, welche Datenbank du verwendest: Speichere den eigentlichen Spielzustand niemals direkt als nacktes Objekt. Verpacke ihn von Tag eins an in eine sogenannte Hülle (SaveEnvelope). Drei Metadatenfelder schützen dich vor den meisten Produktionsfehlern: eine Schemaversion, ein UTC-Zeitstempel und eine Geräte-ID. Der folgende Code zeigt die Struktur in reinem Dart:
class SaveEnvelope {
SaveEnvelope({
required this.schemaVersion,
required this.savedAtUtc,
required this.deviceId,
required this.payload,
});
static const int currentVersion = 1;
final int schemaVersion;
final DateTime savedAtUtc;
final String deviceId;
final Map<String, Object?> payload;
Map<String, Object?> toJson() => {
'schemaVersion': schemaVersion,
'savedAtUtc': savedAtUtc.toIso8601String(),
'deviceId': deviceId,
'payload': payload,
};
static SaveEnvelope? fromJson(Map<String, Object?> json) {
final version = json['schemaVersion'];
if (version is! int || version > currentVersion) {
// Either corrupted, or written by a newer build. Do not guess.
return null;
}
final savedAt = DateTime.tryParse('${json['savedAtUtc']}');
if (savedAt == null) return null;
final payload = json['payload'];
if (payload is! Map<String, Object?>) return null;
return SaveEnvelope(
schemaVersion: version,
savedAtUtc: savedAt,
deviceId: '${json['deviceId']}',
payload: payload,
);
}
}
Beachte die Schutzbedingung in fromJson: Dateien mit einer Versionsnummer, die neuer ist als die von der aktuellen App unterstützte Version, werden sofort verworfen. Dadurch verhindert ein älterer Build, dass neuere Datenstrukturen unwissentlich überschrieben oder beschädigt werden. Stattdessen kannst du dem Nutzer einen sauberen Hinweis anzeigen, dass er die App aktualisieren soll.
Schemaversionierung: Migrationen nur vorwärts
Datenmigrationen sollten aus kleinen, klar abgegrenzten Funktionen bestehen, von denen jede die Schemaversion um genau einen Schritt erhöht. Schreibe keine gigantische Funktion, die jedes beliebige alte Format auf den neuesten Stand hievt, sondern verketten Einzelschritte:
Map<String, Object?> migrateSave(Map<String, Object?> raw) {
var version = raw['schemaVersion'];
if (version is! int) return raw; // Legacy file with no version: treat as v0.
var data = raw;
while (version < SaveEnvelope.currentVersion) {
data = switch (version) {
0 => _v0ToV1(data),
1 => _v1ToV2(data),
_ => data,
};
version = data['schemaVersion'] as int;
}
return data;
}
Map<String, Object?> _v0ToV1(Map<String, Object?> data) => {
...data,
'schemaVersion': 1,
'deviceId': data['deviceId'] ?? 'legacy-device',
};
Map<String, Object?> _v1ToV2(Map<String, Object?> data) => {
...data,
'schemaVersion': 2,
'savedAtUtc': data['savedAtUtc'] ??
DateTime.fromMillisecondsSinceEpoch(0, isUtc: true)
.toIso8601String(),
};
Drei goldene Regeln sorgen für Sicherheit im Produktivbetrieb:
- Erweitere Schemata additiv. Füge neue Eigenschaften mit sinnvollen Standardwerten hinzu, anstatt bestehende Schlüssel umzubenennen oder zu löschen. Ältere Builds ignorieren unbekannte Zusatzfelder problemlos, stürzen bei fehlenden Pflichtfeldern jedoch sofort ab.
- Teste jede Migration mit echten Dateien. Lege für jede veröffentlichte Version eine reale Beispieldatei in deiner Test-Suite ab. Künstlich erstellte Testdaten im Code übersehen häufig subtile Serialisierungsfallen.
- Schreibe Dateien atomar. Schreibe Daten zuerst in eine temporäre Datei, erzwinge das Schreiben auf die Festplatte (
flush) und benenne die Zieldatei anschließend atomar um (rename). Bei einem plötzlichen Stromausfall bleibt so entweder die vollständige alte oder die vollständige neue Datei erhalten, niemals aber ein abgeschnittener Datensatz. Relationale Datenbanken wie SQLite bieten diesen Schutz über Transaktionen standardmäßig.

Fünf technische Fallen, die Entwickler überraschen
1. shared_preferences garantiert kein sofortiges Schreiben auf Festplatte. Die offizielle Dokumentation weist ausdrücklich darauf hin, dass Schreibvorgänge asynchron im Hintergrund erfolgen können und kein Schutz vor Datenverlust besteht, wenn der Prozess direkt nach dem Aufruf beendet wird. Kritische Spielstände gehören daher nicht dorthin. Geht ein Lautstärkewert verloren, stört das niemanden; verschwindet eine 200-Tage-Sudoku-Serie, verlierst du den Spieler. Unter Android empfiehlt sich der Wechsel auf SharedPreferencesAsync, das Daten über DataStore Preferences anstelle veralteter XML-Dateien speichert.
2. Asynchrones Schreiben unter Android und Startverzögerungen. Die Android-Methode apply() kehrt sofort zum Aufrufer zurück, schiebt den echten Festplatten-Flush jedoch auf. In ungünstigen Konstellationen wird dieser Flush beim nächsten Kaltstart der App ausgeführt, was die Ladezeit spürbar verlängert. Bei wenigen Einstellungen fällt das nicht ins Gewicht, bei vielen Updates pro Spielsitzung gerät der Start jedoch ins Stocken.
3. Benchmark-Ergebnisse von Hive spiegeln den Arbeitsspeicher wider. Viele Hive-Benchmarks im Internet messen Lesezeiten aus bereits geöffneten Boxen, die komplett im RAM liegen. Das entspricht zwar dem regulären Einsatzzweck, sagt aber wenig über die Dauer des Kaltstarts oder kontinuierliche Schreiblasten auf Flash-Speicher aus. Berücksichtige bei deiner Planung die Initialisierungszeit nach einem App-Update. Beachte zudem, dass das Originalpaket nicht mehr aktiv betreut wird; nutze in neuen Projekten den hive_ce-Fork.
4. Die lange Entwicklungszeit von Isar als Projektrisiko. Isar 4 befindet sich seit geraumer Zeit in der Entwicklung, ohne dass ein finales Release vorliegt. Eine Datenbank in einem Handyspiel ist eine Verpflichtung über Jahre hinweg, da Nutzer ihre Puzzle-Apps lange behalten. Prüfe vorab das Isar-GitHub-Repository und die offenen Fehlerberichte. Trenne die Datenmodelle sauber von der Speicherlogik, um bei Bedarf die Datenbank ohne Komplettumbau austauschen zu können.
5. JSON-Serialisierung auf dem UI-Isolate führt zu Rucklern. Ein Aufruf von jsonEncode für einen großen Spielstand läuft auf dem Hauptthread von Flutter (UI-Isolate) - also auf demselben Thread, der auch für flüssige Animationen und Gesten verantwortlich ist. Werden umfangreiche Daten nach jedem Zug serialisiert, gerät das Spiel auf älteren Smartphones schnell ins Stottern. Verlagere aufwendige Kodierungsarbeiten mit compute() in einen Hintergrund-Worker oder speichere gezielt nur an Ruhepausen. Praxisnahe Details dazu findest du im Flutter-Kochbuch zur Datenpersistenz.
Vorbereitung auf Cloud-Synchronisation
Zu Beginn eines Projekts steht selten ein fertiges Backend bereit. Es lohnt sich jedoch, die Datenstruktur von Anfang an so anzulegen, dass eine spätere Cloud-Anbindung als einfache Integration umgesetzt werden kann.
Das Save-Envelope-Muster bildet das perfekte Fundament. Beachte zusätzlich folgende Punkte:
- Speichere stets
schemaVersion,deviceIdundsavedAtUtc. Jeder Konfliktlösungsmechanismus basiert auf Metadaten. Ohne Versionsnummer lassen sich Daten nach App-Updates auf unterschiedlichen Geräten nicht zusammenführen. Ohne Zeitstempel fehlt jede Chronologie, und ohne Geräte-ID lässt sich die Ursache fehlerhafter Merges nicht analysieren. - Führe Daten feldweise zusammen statt dateiweise. Löst ein Spieler ein Sudoku offline auf dem Tablet und nutzt kurz darauf einen Hinweis auf dem Smartphone, würde eine einfache Dateiüberschreibung einen dieser Fortschritte vernichten. Ein feldbasiertes Merging bewahrt sowohl das gelöste Rätsel als auch den verbrauchten Hinweis.
- Behalte Speicherlimits der Cloud-Dienste im Blick. Dienste wie Google Play Games Services begrenzen die Größe einzelner Speicher-Slots (oft auf 3 MB). Das ist enorm viel Platz für reine Spielstände, solange du keine Screenshots oder unkomprimierten Logs hineinpackst. Ein schlankes Format sorgt dafür, dass Speicherlimits nie zum Problem werden.
- Vertraue bei der Reihenfolge nie der lokalen Gerätezeit. Spieler manipulieren gerne die Uhr ihres Handys. Nutze den lokalen Zeitstempel (
savedAtUtc) rein zu Informationszwecken in der Oberfläche. Für die verbindliche Reihenfolge in der Cloud sind ausschließlich Server-Zeitstempel maßgeblich. - Synchronisation muss bestehende lokale Daten schützen. Ein erster Cloud-Abgleich darf niemals unbemerkt eine lange lokale Spielhistorie löschen. Im Zweifelsfall ist es sicherer, Datensätze zu kombinieren oder den Spieler explizit wählen zu lassen, welcher Stand behalten werden soll.

Empfohlene Setups für ein Sudoku-Spiel
Die Wahl des richtigen Stacks richtet sich nach der Komplexität deiner Spieldaten:
- Das pragmatische Standard-Setup:
SharedPreferencesAsyncfür einfache Schalter und Einstellungen, kombiniert mithive_cefür den Hauptspielstand. Dieses Setup ist schlank, lässt sich in Unit-Tests blitzschnell prüfen und startet ohne messbare Verzögerung. - Das Statistik-Setup: Die Bibliothek
driftauf Basis von SQLite. Ideal, wenn du jede gelöste Sudoku-Partie archivieren, detaillierte Auswertungen anbieten und Spielern flexible Filterfunktionen bereitstellen möchtest. - Das minimalistische Setup: Eine einzelne versionierte JSON-Datei, die über
path_providermit atomarem Umbenennen geschrieben wird. Wenn dein Spiel nur eine aktive Partie und Basiseinstellungen besitzt, reicht eine JSON-Datei völlig aus.
Checkliste vor der Veröffentlichung
Bevor du ein Update oder dein neues Spiel im Store veröffentlichst, solltest du diese Punkte abhaken:
- Jeder Spielstand speichert
schemaVersion,savedAtUtcunddeviceId. - Der Lader weist Spielstände ab, die aus neueren App-Versionen stammen.
- Dateizugriffe erfolgen atomar (temporäre Datei mit Rename oder Datenbanktransaktion).
- Einfache Optionen liegen in
shared_preferences, der Spielfortschritt in einer sicheren Persistenzschicht. - Für jede frühere Schemaversion existieren echte Testdateien in den Unit-Tests.
- Große Serialisierungen blockieren während des Spiels nicht den UI-Thread.
- Die Speichergröße unter Volllast nach monatelangem Spielen wurde vorab getestet.
Ein zuverlässiges Speichersystem ist das Fundament, auf dem das Vertrauen der Spieler ruht. Baue von Beginn an auf Versionierung und atomare Zugriffe, damit deine Sudoku-App Spielstände und Siegesserien über viele Jahre hinweg sicher bewahrt.
Weiterführende Links
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.




