
Guardar el progreso en un juego con Flutter: shared_preferences vs Hive vs Isar vs SQLite
Cómo guardar datos de partida en Flutter sin perder el progreso de los jugadores. Comparativa de shared_preferences, Hive, Isar y SQLite, versiones y nube.
Publicado el 17 min
En esta página
Un domingo por la mañana abres tu bandeja de entrada y te encuentras con el mensaje de un jugador angustiado. Tras actualizar tu juego de sudoku el día anterior, su racha de 214 días consecutivos ha desaparecido por completo. El tablero que tenía resuelto a la mitad ha vuelto a quedar totalmente vacío.
Al revisar el código, el motivo salta a la vista: el archivo de guardado no incluía un número de versión. La nueva actualización esperaba una estructura de datos diferente, por lo que el deserializador devolvió null de forma silenciosa al toparse con campos imprevistos. Desde el punto de vista técnico, la información nunca se borró del disco; simplemente se volvió ilegible para la nueva compilación. Sin embargo, para el jugador no hay ninguna diferencia: meses de partidas diarias se han perdido.
Gestionar el estado y la persistencia de datos en Flutter (un tema que con frecuencia se busca como flutter game save data) parece algo trivial al principio. Esa ilusión se rompe en cuanto una actualización descuidada estropea los datos de los usuarios. En esta guía práctica comparamos las cuatro soluciones de almacenamiento más extendidas en Flutter: shared_preferences, Hive, Isar y SQLite. Verás qué datos merece la pena escribir en el disco, qué conviene descartar y cómo implementar un patrón probado de sobre de guardado (save envelope) con migraciones de esquema hacia delante. Todos los ejemplos de código están redactados en Dart puro y pueden ejecutarse directamente en DartPad.
Por qué la persistencia es una funcionalidad clave y no solo fontanería
En muchos tutoriales de desarrollo, el guardado de datos se trata como un mero trámite entre el diseño del tablero y el lanzamiento en las tiendas de aplicaciones. Para los jugadores, sin embargo, la integridad de su partida representa un pacto de confianza fundamental. Los juegos de lógica, como el sudoku tradicional, se apoyan en la continuidad: un tablero iniciado en el metro, una racha diaria ininterrumpida y estadísticas acumuladas durante meses generan un vínculo estrecho con el juego. Si una actualización arruina ese historial, el usuario se siente frustrado y, en lugar de empezar de cero, opta por desinstalar la aplicación.
La fiabilidad del guardado repercute de forma directa en la retención. El usuario necesita tener la certeza absoluta de que puede bloquear la pantalla de su teléfono o cambiar de aplicación en cualquier instante sin arriesgarse a perder sus números anotados. Si salir de la partida en pleno desarrollo parece una lotería, la gente deja de abrir el juego en sus pausas cortas. Un sistema de guardado sólido y predecible es una de las inversiones más rentables para fidelizar a los jugadores.
Las cuatro alternativas de almacenamiento en Flutter
En la práctica, casi cualquier proyecto móvil en Flutter se apoya en una de estas cuatro opciones. Cada herramienta fue concebida para resolver necesidades distintas y ofrece ventajas y concesiones claras.
shared_preferences es el plugin oficial de clave-valor mantenido por el equipo de Flutter. Funciona como una capa sobre los mecanismos nativos de cada sistema: NSUserDefaults en iOS y macOS, Android SharedPreferences o la biblioteca moderna DataStore Preferences. Admite tipos primitivos: int, double, bool, String y List<String>. Desde la versión 2.3.0, el paquete incorpora dos interfaces modernas: SharedPreferencesAsync y SharedPreferencesWithCache, mientras que la antigua clase SharedPreferences ha quedado obsoleta. Resulta una opción ideal para guardar ajustes de volumen, temas visuales o banderas de configuración, pero no debe emplearse como el almacén principal de la partida.
Hive es una base de datos ligera de clave-valor desarrollada en Dart puro e inspirada en Bitcask. Los datos se distribuyen en cajas (boxes) que pueden ser tipadas o dinámicas. En cuanto se abre una caja, las lecturas se ejecutan de forma síncrona directamente desde la memoria RAM, lo que proporciona accesos ultrarrápidos. Aunque el creador original delegó el mantenimiento del proyecto, la comunidad lo sostiene y actualiza mediante la bifurcación oficial hive_ce. Hive encaja a la perfección en juegos de lógica casuales y proyectos medianos con estructuras de datos bien definidas.
Isar es una base de datos NoSQL avanzada concebida por el mismo desarrollador. Proporciona consultas indexadas, enlaces entre objetos y soporte completo para transacciones ACID. La versión 3 es madura y estable. No obstante, el desarrollo de Isar 4 se ha prolongado durante mucho tiempo y el ritmo de actualizaciones ha descendido notablemente. Antes de elegir Isar para un nuevo desarrollo comercial, revisa la actividad en el repositorio de Isar en GitHub para cerciorarte de que su cadencia encaja con los plazos de tu proyecto.
SQLite, integrado habitualmente en Flutter mediante el paquete sqflite o la capa tipada drift, es el estándar relacional de referencia. Garantiza pleno cumplimiento de ACID, décadas de fiabilidad contrastada y soporte para el modo WAL (Write-Ahead Logging), ideal para lecturas paralelas muy rápidas. Permite gestionar con soltura miles de partidas de sudoku terminadas con el registro detallado de cada movimiento y estadísticas complejas. A cambio, exige más trabajo inicial para definir esquemas, redactar consultas y planificar migraciones de tablas.
Tabla comparativa
| Herramienta | Dificultad de configuración | Rapidez de lectura y escritura | Tamaño óptimo de datos | Caso de uso ideal |
|---|---|---|---|---|
| shared_preferences | Muy baja | Rápida para claves aisladas | Hasta unos pocos KB | Ajustes de audio, tema, tutorial |
| Hive | Baja | Ultrarrápida (en RAM) | Hasta varios MB por caja | Archivo principal de juegos casuales y lógica |
| Isar | Media | Muy veloz con índices | De varios MB a decenas | Modelos complejos con relaciones y filtros |
| SQLite (sqflite / drift) | Media a alta | Gran fiabilidad, ACID, WAL | Cualquier volumen con índices | Historial de partidas, métricas, varias tablas |

Diseña siempre tu arquitectura pensando en el escenario más exigente y no en la partida inicial. El estado de un único tablero de sudoku ocupa menos de un kilobyte. Ahora bien, si un jugador constante reúne al cabo de un año mil partidas resueltas con marcas de tiempo y métricas por celda, el volumen de datos crecerá de manera considerable. Elige una herramienta que conserve un rendimiento impecable tras meses de uso intenso.
Qué conviene guardar y qué es preferible omitir
La operación de disco más rápida es aquella que no hace falta llevar a cabo. Antes de escribir el código de persistencia, conviene determinar con claridad qué elementos merecen ocupar espacio en la memoria no volátil.
Datos que conviene guardar:
- El estado del tablero en curso. En un juego de sudoku: el identificador del reto, los números iniciales dados (o la semilla generadora), las entradas actuales del jugador, las anotaciones a lápiz y el contador de movimientos. Guarda el tiempo jugado como milisegundos acumulados (
elapsedMs) en lugar de almacenar un objetoDateTimeen tiempo real. Así evitarás desfases si el usuario cambia de zona horaria o bloquea el dispositivo durante horas. - Ajustes del jugador. Volumen de la música y efectos sonoros, vibración (respuesta háptica), tema de color preferido y nivel de dificultad elegido.
- Estadísticas y rachas. Victorias acumuladas, tiempos medios, mejores marcas y la racha diaria activa junto con la fecha de la última victoria contabilizada. Disponer de una fecha de referencia permite verificar la validez de la racha tras reiniciar la aplicación; un valor numérico aislado como
streak = 12no permite contrastar nada si surge una incidencia técnica. - Banderas de progreso. Confirmación de haber completado el tutorial o la fecha en que se mostró la solicitud de reseña en la tienda.
Datos que no se deben guardar:
- Datos recalculables. La lista de números candidatos para cada casilla de un sudoku puede deducirse a partir del estado de la cuadrícula en microsegundos. Guardar esa información en el archivo infla el almacenamiento y genera incongruencias si modificas tus algoritmos de ayuda.
- Estados volátiles de la interfaz. La posición de desplazamiento en un menú, los diálogos modales abiertos o el fotograma de una animación forman parte de la presentación. Al volver a abrir la pantalla, estos elementos deben reconstruirse desde cero.
- Capturas completas tras cada toque en pantalla. Guarda la partida en hitos naturales: tras una serie de jugadas, al pausar el juego o cuando la aplicación pasa a segundo plano. Aunque el formato JSON de un sudoku sea ligero, efectuar cientos de escrituras por minuto desgasta innecesariamente la memoria flash y gasta batería.
- La hora tomada a ciegas del reloj del dispositivo. Los jugadores a menudo modifican la hora del sistema para recuperar vidas o esquivar límites diarios. Reserva la hora del dispositivo exclusivamente para mostrarla en pantalla. Para la mecánica del juego y la validación de rachas, utiliza contadores monotónicos o sellos de tiempo validados por tu servidor.
La siguiente clase de datos ilustra cómo organizar el estado de un tablero de sudoku. Todos los campos representan exclusivamente el estado inicial, las jugadas o contadores acumulados. El código es Dart puro y funciona sin modificaciones en 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,
};
}
El patrón de sobre de guardado: defensa frente a la corrupción
Independientemente del motor de base de datos que emplees, jamás almacenes el estado de tu juego como un objeto suelto. Envuélvelo siempre dentro de un patrón de sobre (SaveEnvelope). Tres metadatos básicos te ahorrarán innumerables contratiempos en producción: la versión del esquema, una marca temporal en UTC y el identificador del dispositivo. La siguiente muestra en Dart puro refleja esta arquitectura:
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,
);
}
}
Presta atención a la condición de guarda en el método fromJson: cualquier archivo con una versión posterior a la soportada por la aplicación en ejecución se rechaza al instante. Esta sencilla verificación impide que una versión antigua de la aplicación sobreescriba un archivo más reciente y destruya campos que todavía no conoce. En lugar de un cierre imprevisto, podrás mostrar al usuario un mensaje solicitándole que actualice el juego.
Versionado del esquema y migraciones exclusivamente hacia delante
Las migraciones de datos deben articularse en funciones breves y especializadas, cada una de las cuales eleva la versión del esquema exactamente un nivel. No intentes construir una función colosal que transforme cualquier variante antigua en la más actual. Resulta mucho más seguro concatenar pequeños pasos en cadena:
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(),
};
Tres hábitos indispensables para trabajar con seguridad en entornos de producción:
- Aplica cambios de forma aditiva. En lugar de eliminar propiedades existentes o renombrarlas, añade nuevos atributos con valores predeterminados adecuados. Las versiones anteriores del código ignorarán los campos nuevos sin inmutarse, mientras que la falta de un campo esperado suele provocar una excepción de inmediato.
- Comprueba las migraciones con archivos de guardado auténticos. Guarda en tus pruebas unitarias archivos de ejemplo reales procedentes de cada versión publicada en el pasado. Fabricar datos ficticios manualmente dentro de los tests a menudo oculta problemas reales de serialización.
- Escribe en disco de forma atómica. Guarda los datos en un archivo temporal, fuerza el vaciado del búfer al disco (
flush) y sustituye el archivo final mediante una operación de renombrado (rename). En caso de corte de energía durante la escritura, se conservará la versión anterior completa o la nueva recién escrita, pero nunca un archivo truncado por la mitad. Los motores relacionales como SQLite integran esta garantía de fábrica a través de transacciones.

Cinco escollos técnicos que sorprenden a los desarrolladores
1. shared_preferences no garantiza escrituras inmediatas en disco. La documentación del paquete advierte con claridad de que las operaciones de guardado pueden ejecutarse de forma asíncrona en segundo plano, sin garantía de que los datos sobrevivan si el proceso termina de repente. Por ello, jamás debes almacenar allí información crucial de la partida. Perder un nivel de brillo es irrelevante, pero perder una racha de 200 días en sudoku arruina la confianza del usuario. En Android, utiliza la nueva interfaz SharedPreferencesAsync, que guarda los datos mediante DataStore Preferences en vez de los viejos archivos XML.
2. Escritura asíncrona en Android y demoras en el arranque. El método apply() de Android devuelve el control al código de inmediato, pero pospone la escritura física en el almacenamiento. En condiciones desfavorables, el sistema vuelca ese búfer durante el siguiente inicio en frío de la aplicación, lo que retrasa de forma palpable el tiempo de carga. Si bien con pocas opciones este efecto pasa desapercibido, cuando se realizan decenas de escrituras en una misma partida la fluidez del arranque se resiente.
3. Los resultados de rendimiento de Hive reflejan la memoria RAM. Gran parte de las pruebas de velocidad de Hive disponibles en la red miden lecturas efectuadas sobre cajas ya abiertas y cargadas en RAM. Aunque ese sea el modo habitual de trabajo, no refleja el tiempo de inicio en frío ni la tasa de escritura sostenida en memorias flash. Ten muy en cuenta el tiempo de carga inicial tras una actualización. Asimismo, recuerda que el paquete original ya no se actualiza activamente, por lo que en desarrollos nuevos se aconseja utilizar la bifurcación hive_ce.
4. La prolongada espera de Isar como riesgo tecnológico. El desarrollo de Isar 4 continúa abierto tras un largo periodo sin versión final estable. Apostar por un motor de base de datos en un juego móvil representa un compromiso para varios años, dado que los jugadores conservan sus juegos de lógica durante mucho tiempo. Comprueba el repositorio de Isar en GitHub y su registro de incidencias antes de dar el paso. Conviene además desacoplar los modelos de datos de la lógica de guardado para facilitar un cambio de biblioteca si fuese necesario.
5. Serializar un JSON voluminoso en el hilo de interfaz produce tirones. Invocar jsonEncode sobre un estado de juego amplio se ejecuta en el hilo principal de Flutter (UI isolate), el mismo encargado de renderizar fotogramas y responder a los toques. Realizar esta operación tras cada movimiento en teléfonos modestos provoca caídas de cuadros visibles. Deriva las tareas pesadas de codificación a un hilo secundario mediante compute() o reserva el guardado para pausas lógicas. Encontrarás más recomendaciones en la guía oficial de persistencia de Flutter.
Cómo preparar la arquitectura para sincronizar con la nube
Al principio de un proyecto casi nunca se dispone de un servidor propio. No obstante, planificar la estructura de datos local con antelación permite que añadir sincronización en la nube en el futuro sea una integración sencilla y no un motivo para rehacer el juego entero.
El patrón de sobre de guardado aporta una base inmejorable. Pon en práctica estos consejos adicionales:
- Conserva siempre
schemaVersion,deviceIdysavedAtUtc. Los algoritmos de resolución de conflictos dependen de los metadatos. Sin número de versión no podrás unificar datos entre versiones distintas del juego. Sin sellos temporales carecerás de orden cronológico, y sin el identificador del dispositivo no podrás averiguar qué terminal originó un conflicto. - Combina la información campo por campo en lugar de sobreescribir el archivo entero. Imagina a un jugador que resuelve un sudoku sin conexión en su tableta y una hora después pide una pista desde su teléfono. Un sistema elemental que sobreescriba el archivo más viejo borraría uno de los dos progresos. Fusionar los datos a nivel de propiedad individual permite conservar tanto el puzle resuelto como la pista utilizada.
- Respeta los límites de tamaño de los servicios en la nube. Plataformas como Google Play Games Services imponen límites estrictos al tamaño de cada ranura de guardado (a menudo un máximo de 3 MB). Es una capacidad enorme para datos puros de juego, siempre que no cometas el error de adjuntar capturas de pantalla o registros de depuración sin comprimir.
- Nunca te fíes del reloj del teléfono para ordenar eventos. Los usuarios pueden manipular la hora de su dispositivo. Trata el sello temporal local (
savedAtUtc) como un dato orientativo para la interfaz. Para resolver discrepancias en la nube, básate siempre en los sellos horarios emitidos por tu servidor. - La sincronización debe respetar el historial local del jugador. Un primer inicio de sesión en la nube nunca debe borrar silenciosamente meses de progreso almacenados en el teléfono. Ante cualquier divergencia, resulta preferible fusionar la información o consultar directamente al jugador qué estado desea conservar.

Configuraciones recomendadas para un juego de sudoku
La elección de herramientas dependerá de la envergadura del título y del volumen de datos que desees registrar:
- Combinación pragmática predeterminada:
SharedPreferencesAsyncpara opciones sencillas junto conhive_cepara el archivo central de la partida. Una solución ágil y liviana que se evalúa al instante en pruebas unitarias y arranca sin demoras perceptibles. - Combinación para métricas detalladas: la biblioteca
driftapoyada en SQLite. La opción más adecuada si necesitas conservar el historial de cada partida de sudoku jugada, generar balances temporales detallados y ofrecer filtros de búsqueda a los usuarios. - Combinación minimalista: un único archivo JSON gestionado a través de
path_providercon renombrado atómico. Si tu juego maneja una sola partida activa y opciones elementales, un archivo JSON estructurado resulta más que suficiente.
Lista de comprobación antes de publicar
Antes de enviar el juego o una actualización importante a las tiendas, comprueba estos puntos:
- Cada registro de guardado incluye
schemaVersion,savedAtUtcydeviceId. - El deserializador rechaza archivos de versiones más modernas para evitar corrupciones.
- La escritura en disco es atómica (archivo provisional con renombrado o transacción en base de datos).
- Las preferencias comunes se alojan en
shared_preferences, mientras que el progreso se guarda en un soporte duradero. - Cuentas con archivos de prueba reales de cada versión anterior del esquema en tus tests unitarios.
- La serialización de datos no satura el hilo de interfaz durante la experiencia de juego.
- Has medido el tamaño de almacenamiento en el escenario más exigente tras meses de partidas.
Un sistema de guardado impecable es el pilar sobre el que descansa la confianza de tus jugadores. Incorpora el versionado de esquemas y las escrituras atómicas desde el primer commit: tu juego de sudoku protegerá las partidas y las rachas de los usuarios durante muchos años.
Lecturas recomendadas
- shared_preferences en pub.dev
- hive_ce, la versión actualizada de Hive
- Isar en GitHub
- sqflite y drift
- Documentación de Android DataStore
- Modo WAL en SQLite
- Más artículos de nuestro estudio: De dónde surgen las ideas para juegos, Técnicas de memoria aplicadas al diseño de puzles y Accesibilidad en videojuegos 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.
Un único correo en el lanzamiento, nada de spam.




