Realm en aplicaciones móviles: qué es y cómo funciona

¿Qué es Realm?

Realm es una base de datos orientada a objetos creada específicamente para aplicaciones móviles. A diferencia de SQLite, Realm no utiliza SQL ni un modelo relacional: los datos se almacenan como objetos vivos (Live Objects), a los que se accede directamente sin una capa ORM intermedia. El desarrollador trabaja con objetos regulares del lenguaje (Swift, Kotlin, Dart) que se guardan automáticamente en la base de datos.

Realm apareció en 2014 como la startup Realm Inc., y en 2019 fue adquirida por MongoDB Inc. Desde entonces, Realm se ha desarrollado como MongoDB Realm, parte de la plataforma unificada Atlas Device Sync para la sincronización de datos móviles. La base de datos local básica de Realm sigue siendo gratuita y de código abierto (licencia Apache 2.0), mientras que Realm Sync (sincronización en la nube) se distribuye mediante suscripción.

Según el MongoDB Developer Report (2025), Realm se utiliza en el 15% de las aplicaciones móviles como almacenamiento local principal. Los principales casos de uso son aplicaciones con modo offline, modelos de objetos complejos y necesidad de sincronización entre dispositivos, donde Realm supera a SQLite en velocidad de desarrollo y facilidad de trabajo con objetos.

Principios de Realm

Live Objects — cada objeto de Realm está vinculado al disco a través de un archivo mapeado en memoria (memory-mapped file). El cambio de un objeto en cualquier hilo se refleja inmediatamente en todos los demás hilos sin notificación manual. La interfaz de usuario se redibuja automáticamente cuando los datos cambian a través de las notificaciones de Realm. Zero-copy — Realm no copia los datos de la base de datos en objetos; los objetos son los datos en memoria.

Cómo funciona Realm: arquitectura y almacenamiento

El núcleo de Realm está escrito en C++ y utiliza B+ Tree para la indexación de datos. A diferencia de SQLite, donde cada fila es un registro en una tabla relacional, Realm almacena objetos como nodos en una estructura de grafo con referencias directas entre ellos (forward pointers). Las relaciones entre objetos no son claves foráneas sino punteros directos, lo que elimina la necesidad de operaciones JOIN.

Los archivos de Realm (extensión .realm) están mapeados en memoria (memory-mapped): el propio sistema operativo gestiona la carga de las páginas del archivo en memoria a medida que se accede a ellas. Esto permite a Realm trabajar con bases de datos más grandes que la RAM disponible y proporciona una latencia de lectura al nivel de las estructuras de datos nativas del lenguaje (Swift Array o Kotlin List) para los datos que caben en RAM.

Zero-copy y Live Objects

Archivos mapeados en memoria — la tecnología clave de Realm. En lugar de copiar los datos del archivo de la base de datos en objetos del lenguaje (como hace SQLite mediante sqlite3_step + sqlite3_column_*), Realm mapea el archivo de la base de datos directamente en el espacio de direcciones del proceso. Los objetos del lenguaje son simplemente punteros a los datos en la memoria mapeada. Cambiar un objeto modifica la base de datos en el disco sin una llamada save separada.

El consumo de memoria es mayor en Realm durante la lectura activa (todo el archivo o una gran parte está mapeada en memoria), pero menor durante las operaciones de escritura, ya que no se requiere asignación de memoria para copias de objetos. Para bases de datos de hasta 1 GB en dispositivos móviles, el enfoque memory-mapped proporciona un mejor rendimiento general que SQLite con su copia intermedia.

Realm vs SQLite vs Core Data: comparación

SQLite es un sistema de gestión de bases de datos relacional con SQL y transacciones ACID. Realm es una base de datos NoSQL orientada a objetos con acceso memory-mapped. Core Data es la capa ORM de Apple sobre SQLite. Cada uno de los tres enfoques tiene su propia área de aplicación y puntos fuertes. Realm gana en velocidad de acceso directo a objetos y reactividad, SQLite en versatilidad y madurez, Core Data en integración con el ecosistema de Apple.

El rendimiento de lectura de Realm es un 10-50% más alto que SQLite gracias al acceso zero-copy. Realm también es más rápido en escritura debido a la ausencia de análisis sintáctico SQL y la modificación directa de las páginas memory-mapped. Sin embargo, Realm puede consumir más RAM al trabajar con bases de datos grandes (>500 MB), ya que el archivo se mapea completamente en el espacio de direcciones.

La elección entre Realm y SQLite a menudo se reduce a prioridades: velocidad de desarrollo y reactividad (Realm) frente a control y versatilidad (SQLite). Realm es especialmente bueno para MVPs y prototipos donde el modelo de datos cambia con frecuencia y es importante obtener actualizaciones de UI en vivo rápidamente. SQLite/Room es preferible para productos maduros con grandes volúmenes de datos y consultas analíticas complejas.

Realm en Android: Kotlin SDK

Realm Kotlin SDK es la biblioteca oficial para Android, escrita en Kotlin (no es un envoltorio sobre Java SDK). El modelo de datos se define mediante clases que heredan de RealmObject, con la anotación @PrimaryKey para un identificador único. Realm Kotlin admite Kotlin Coroutines, Flow y KSP (Kotlin Symbol Processing) para generación de código en tiempo de compilación.

RealmQuery proporciona una API type-safe para filtrado sin SQL. Las consultas se construyen mediante una cadena de métodos: query → filter → sort → find. El resultado puede devolverse como una lista (cargada en memoria) o como un Flow (flujo reactivo que se actualiza cuando los datos cambian). Realm Kotlin también admite objetos anidados y listas (RealmList).

Ejemplo de Realm Kotlin SDK

Modelo de datos Realm se define como una clase de datos que implementa la interfaz RealmObject. El campo _id está marcado con @PrimaryKey para identificación única. La relación uno-a-muchos se implementa mediante RealmList, una lista de otros RealmObject. Todas las operaciones de escritura (crear, actualizar, eliminar) se realizan dentro de un bloque de transacción write.

class Project : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId().generate()
    var name: String = ""
    var tasks: RealmList<Task> = realmListOf()
}

class Task : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId().generate()
    var title: String = ""
    var isComplete: Boolean = false
}

val config = Realm.Configuration.Builder(
    schema = setOf(Project::class, Task::class)
).build()

val realm = Realm.open(config)
realm.write { transactionRealm ->
    val project = copyToRealm(Project().apply {
        name = "Mobile App"
    })
    project.tasks.add(copyToRealm(Task().apply {
        title = "Design UI"
    }))
}

val projects: Flow<RealmResults<Project>> =
    realm.query<Project>()
        .sort(Project::name, Sort.ASCENDING)
        .asFlow()

Una consulta que devuelve Flow emite automáticamente nuevos resultados ante cualquier cambio de datos en Realm: añadir, actualizar o eliminar un Project o Task. El enfoque Flow se combina perfectamente con Compose: collectAsState() en el ViewModel recompone automáticamente la UI cuando los datos cambian sin necesidad de actualizar manualmente los adaptadores de lista ni usar LiveData.

Realm en iOS: Swift SDK

Realm Swift SDK proporciona una API nativa de Swift con soporte para async/await, Combine Publishers y Swift Concurrency. Los modelos de datos se definen como clases que heredan de Object, utilizando @Persisted para las propiedades. Realm Swift actualiza automáticamente los objetos en los cambios, y las notificaciones (NotificationToken) permiten suscribirse a cambios de objetos o colecciones individuales.

@ObservedRealmObject y @ObservedResults son Property Wrappers para SwiftUI que redibujan automáticamente la Vista cuando los datos de Realm cambian. @ObservedResults funciona con resultados de consulta, @ObservedRealmObject con un objeto específico. Ambas propiedades cancelan la suscripción cuando la Vista se desinicializa.

Ejemplo de Realm Swift SDK

Integración con SwiftUI Realm es uno de los puntos fuertes del SDK. El Property Wrapper @ObservedResults vincula una consulta de Realm con la visualización en SwiftUI. Cuando cualquier tarea cambia, SwiftUI recompone automáticamente la lista. realm.writeAsync realiza transacciones en un hilo de fondo sin bloquear la UI.

import RealmSwift

class TaskItem: Object, Identifiable {
    @Persisted(primaryKey: true) var _id: ObjectId
    @Persisted var title: String = ""
    @Persisted var isDone: Bool = false
    @Persisted var priority: Int = 0
}

struct TaskListView: View {
    @ObservedResults(TaskItem.self,
        sortDescriptor: SortDescriptor(["priority"]))
    var tasks

    var body: some View {
        List {
            ForEach(tasks) { task in
                TaskRow(task: task)
            }
        }
        Button("Add Task") {
            let realm = try! Realm()
            try! realm.write {
                realm.add(TaskItem(value: ["title": "New task"]))
            }
        }
    }
}

@ObservedResults gestiona automáticamente el ciclo de vida de la consulta de Realm: cuando se crea la Vista, se crea una suscripción a los cambios; cuando se destruye, se cancela. El Property Wrapper acepta un predicado opcional (NSPredicate) y un descriptor de ordenación. Esto elimina la necesidad de escribir manualmente solicitudes fetch, crear ViewModels y suscribirse a las notificaciones de Realm.

Casos de uso de Realm

Aplicaciones offline — Realm es ideal para escenarios donde los datos deben estar disponibles sin internet. La sincronización integrada (Realm Sync con MongoDB Atlas) resuelve automáticamente los conflictos al conectarse a la red. La aplicación sigue funcionando con datos locales, y la sincronización en segundo plano los actualiza cuando hay conexión disponible.

Interfaces reactivas — Live Objects y las notificaciones Flow/Combine convierten a Realm en una opción conveniente para aplicaciones con datos que se actualizan con frecuencia: chats, feeds de tareas, documentos colaborativos. La UI se actualiza automáticamente cuando se añaden, modifican o eliminan datos sin necesidad de llamar manualmente a reloadData o invalidate.

Proyectos multiplataforma — Realm admite Kotlin Multiplatform (KMP), Flutter, React Native y Xamarin. El modelo de datos se define una vez y se utiliza en todas las plataformas. Esto reduce la duplicación de código y garantiza la consistencia del esquema entre aplicaciones iOS y Android con lógica de negocio compartida.

Realm Sync: sincronización a través de MongoDB Atlas

Realm Sync es un servicio en la nube integrado en MongoDB Atlas. La aplicación sincroniza automáticamente los datos entre los dispositivos del usuario y el servidor. Los conflictos se resuelven mediante la estrategia "last write wins" o mediante funciones personalizadas de resolución de conflictos en el servidor. Realm Sync admite sincronización parcial (subconjunto de datos) para reducir el tráfico.

class SyncRepository {
    private val app = App(
        AppConfiguration(
            appId = "my-realm-app-id"
        )
    )

    suspend fun syncData() {
        val user = app.login(Credentials.anonymous())
        val config = SyncConfiguration.Builder(
            user, setOf(Project::class)
        ).build()

        val syncedRealm = Realm.open(config)
        // La sincronización automática está activa
    }
}

SyncConfiguration configura la conexión a MongoDB Atlas y define el conjunto de modelos a sincronizar. Tras la autenticación del usuario, Realm carga automáticamente los datos desde la nube y los fusiona con los cambios locales. La sincronización se ejecuta en un hilo de fondo y no requiere llamadas manuales: basta con crear una instancia de Realm con SyncConfiguration.