Introduction
RealmSwift is a mobile database that provides a modern alternative to Core Data and SQLite for iOS and macOS applications. Designed from the ground up for mobile development, RealmSwift offers superior performance, an intuitive API, and seamless integration with SwiftUI and UIKit. Unlike traditional relational databases, Realm uses an object-oriented approach where your data models are native Swift classes that inherit from the Object base class using the @Persisted property wrapper.
The framework has become increasingly popular among iOS developers because it eliminates many of the pain points associated with traditional mobile persistence solutions. Core Data, while powerful, comes with a steep learning curve and verbose boilerplate code. SQLite requires you to write raw SQL queries and manually handle the impedance mismatch between relational data structures and Swift objects. For teams evaluating cross-platform solutions, understanding how Realm compares to alternatives like React Native vs Flutter can help inform your technology stack decisions.
RealmSwift also distinguishes itself through its real-time data capabilities and offline-first architecture. The database supports automatic data synchronization with MongoDB Realm Sync, enabling developers to build collaborative applications where changes propagate instantly across all connected devices.
Key advantages for mobile development projects
Superior Performance
Up to 10x faster than SQLite with zero-copy architecture and lazy loading that only loads data you need into memory
Swift-Native API
Modern `@Persisted` property wrapper provides type-safe model definitions without ORM complexity or SQL queries
SwiftUI Integration
Seamless `@ObservedResults` property wrapper automatically updates views when underlying data changes
Cross-Platform Support
Consistent APIs across iOS, Android, and React Native enable efficient multi-platform development
Installation and Project Setup
Getting started with RealmSwift requires proper project configuration. The installation process has been streamlined through Swift Package Manager, Apple's recommended dependency management system for modern Swift projects.
Choose the approach that fits your project workflow
Swift Package Manager
Add https://github.com/realm/realm-swift via Xcode's Package Dependencies for fastest builds and tightest Xcode integration
CocoaPods
Add 'pod RealmSwift' to your Podfile, run 'pod install' - ideal for projects relying on pods not yet available through SPM
Manual Integration
Download prebuilt frameworks from GitHub releases for explicit control over dependencies in CI/CD environments
1import RealmSwift2 3@main4struct MyApp: App {5 init() {6 let config = Realm.Configuration(7 schemaVersion: 1,8 migrationBlock: { migration, oldSchemaVersion in9 if oldSchemaVersion < 1 {10 // Handle migrations for schema version 111 }12 }13 )14 Realm.Configuration.defaultConfiguration = config15 }16 17 var body: some Scene {18 WindowGroup {19 ContentView()20 }21 }22}Defining Data Models with Modern RealmSwift
Data modeling in RealmSwift has evolved with the introduction of the @Persisted property wrapper, which provides a cleaner and more Swifty syntax for defining persisted properties. This modern approach replaces the older @objc dynamic pattern with a more explicit and type-safe declaration that aligns with Swift's property wrapper conventions.
1import RealmSwift2 3class ComicBook: Object, Identifiable {4 @Persisted var title: String = ""5 @Persisted var character: String = ""6 @Persisted var issue: Int = 07 @Persisted var publicationDate: Date = Date()8 @Persisted var coverImagePath: String?9 @Persisted var isFavorite: Bool = false10 11 @Persisted(primaryKey: true) var id: ObjectId12 13 convenience init(title: String, character: String, issue: Int) {14 self.init()15 self.title = title16 self.character = character17 self.issue = issue18 }19}Relationships and Object Linking
RealmSwift supports sophisticated data relationships through its linking objects mechanism. For one-to-many relationships, use the List<T> container type, which behaves like an array but with additional Realm-specific capabilities such as automatic change tracking and query-based filtering. This pattern enables powerful queries that traverse relationships without requiring manual join operations.
1class Character: Object, Identifiable {2 @Persisted var name: String = ""3 @Persisted var realName: String = ""4 @Persisted var comics: List<ComicBook>5 6 @Persisted(primaryKey: true) var id: ObjectId7}8 9class User: Object, Identifiable {10 @Persisted var username: String = ""11 @Persisted var email: String = ""12 @Persisted var posts: List<Post>13 @Persisted var following: List<User>14 15 @Persisted(primaryKey: true) var id: ObjectId16}17 18class Post: Object, Identifiable {19 @Persisted var title: String = ""20 @Persisted var content: String = ""21 @Persisted var author: User?22 @Persisted var likes: List<Like>23 @Persisted var createdAt: Date = Date()24 25 @Persisted(primaryKey: true) var id: ObjectId26}27 28class Like: Object, Identifiable {29 @Persisted var user: User?30 @Persisted var post: Post?31 @Persisted var createdAt: Date = Date()32 33 @Persisted(primaryKey: true) var id: ObjectId34}CRUD Operations
The fundamental Create, Read, Update, and Delete (CRUD) operations form the backbone of any database interaction. RealmSwift provides a clean, Swifty API for performing each of these operations without SQL queries or ORM layers. Every modification to Realm data must occur within a write transaction, ensuring data consistency. When building robust mobile applications, proper data layer implementation is essential - our mobile app development services can help you implement production-ready data persistence strategies.
1let realm = try! Realm()2 3// Creating Objects4let newComic = ComicBook(title: "The Amazing Spider-Man #1", character: "Spider-Man", issue: 1)5newComic.publicationDate = Date()6 7try! realm.write {8 realm.add(newComic)9}10 11// Reading Objects with NSPredicate12let predicate = NSPredicate(format: "character == %@", "Spider-Man")13let spiderManComics = realm.objects(ComicBook.self)14 .filter(predicate)15 .sorted(byKeyPath: "publicationDate", ascending: true)16 17// Updating Objects18try! realm.write {19 comic.title = "Updated Title"20 comic.isFavorite = true21}22 23// Deleting Objects24try! realm.write {25 realm.delete(comicToDelete)26}SwiftUI Integration with @ObservedResults
RealmSwift integrates seamlessly with SwiftUI through the @ObservedResults property wrapper, which monitors the database for changes and automatically invalidates views when relevant changes occur. This integration eliminates manual refresh logic and enables reactive UIs that reflect the current state of your persisted data. For teams comparing mobile development approaches, understanding how SwiftUI with Realm compares to Kotlin vs Java for Android development can help inform cross-platform architecture decisions.
1import SwiftUI2import RealmSwift3 4struct ComicBookListView: View {5 @ObservedResults(ComicBook.self,6 sortDescriptor: SortDescriptor(keyPath: \ComicBook.publicationDate, ascending: false))7 var comics8 9 var body: some View {10 List {11 ForEach(comics) { comic in12 NavigationLink(destination: ComicDetailView(comic: comic)) {13 ComicRowView(comic: comic)14 }15 }16 .onDelete(perform: deleteComics)17 }18 .navigationTitle("Comics")19 }20 21 private func deleteComics(at offsets: IndexSet) {22 $comics.remove(atOffsets: offsets)23 }24}Realm Configurations and Advanced Setup
Realm configurations control how the database behaves, including file locations, schema versions, migration handling, and encryption. Understanding these configuration options is essential for building production applications that handle schema evolution and protect sensitive user data.
1// Custom Realm Configuration2var config = Realm.Configuration()3 4// Custom file location5config.fileURL = config.fileURL?6 .deletingLastPathComponent()7 .appendingPathComponent("ComicCollection.realm")8 9// Enable schema version tracking10config.schemaVersion = 211 12// Set migration block for schema changes13config.migrationBlock = { migration, oldSchemaVersion in14 if oldSchemaVersion < 1 {15 migration.renameProperty(onType: ComicBook.className(),16 from: "dateCreated", to: "publicationDate")17 }18 if oldSchemaVersion < 2 {19 migration.enumerateObjects(ofType: ComicBook.className()) { oldObject, newObject in20 newObject?["isFavorite"] = false21 }22 }23}24 25Realm.Configuration.defaultConfiguration = config26 27// In-memory database for testing28let testConfig = Realm.Configuration()29testConfig.inMemoryIdentifier = "TestDatabase"Best Practices for Production Applications
Following established best practices when using RealmSwift will help you build applications that are performant, maintainable, and free from common pitfalls.
Key Recommendations
Efficient Write Transactions - Batch multiple changes into single write transactions to minimize overhead. Each write transaction involves disk I/O, so grouping operations dramatically improves throughput.
Query Optimization - Use @Persisted(indexed: true) on frequently-queried fields for better query performance. Avoid functions in predicates that prevent index usage.
Thread Safety - Realm objects are thread-confined. Each thread must create its own Realm instance. Use ThreadSafeReference for passing objects between threads safely.
Change Notifications - Use Realm's notification system for reactive updates. Remember to invalidate notification tokens to prevent memory leaks.
1// OPTIMIZED: Batch write transactions2func importComicsAsync(comics: [ComicBook]) {3 DispatchQueue.global(qos: .background).async {4 let realm = try! Realm()5 try! realm.write {6 for comic in comics {7 realm.add(comic)8 }9 }10 }11}12 13// Indexed properties for query optimization14class ComicBook: Object, Identifiable {15 @Persisted(indexed: true) var character: String = ""16 @Persisted(indexed: true) var publicationDate: Date = Date()17 @Persisted var title: String = ""18 19 @Persisted(primaryKey: true) var id: ObjectId20}21 22// Thread-safe object transfer23func transferObjectBetweenThreads(_ comic: ComicBook) {24 let reference = ThreadSafeReference(to: comic)25 DispatchQueue.global().async {26 let realm = try! Realm()27 guard let transferredComic = realm.resolve(reference) else { return }28 // Use transferredComic on this thread29 }30}Frequently Asked Questions
How does RealmSwift compare to Core Data?
RealmSwift offers a simpler API with less boilerplate, native Swift syntax using @Persisted property wrappers without Objective-C runtime dependencies, and automatic change tracking through @ObservedResults. Core Data has a steeper learning curve but integrates more deeply with Apple's ecosystem.
What is the difference between @Persisted and @objc dynamic?
@Persisted is the modern RealmSwift property wrapper that provides a cleaner, more type-safe syntax. It replaces the older @objc dynamic pattern used in legacy Realm code. The new syntax aligns with Swift's property wrapper conventions and is recommended for new projects.
Can RealmSwift objects be shared between threads?
No, Realm objects are thread-confined. Each thread must create its own Realm instance and query for objects it needs to access. Use ThreadSafeReference for safely passing objects between threads.
How do I handle database migrations?
Set a schemaVersion in your Realm.Configuration and provide a migrationBlock. Realm will automatically run migrations when the schema version increases, allowing you to transform data from old to new format.
Is RealmSwift free for commercial use?
Yes, RealmSwift is free and open-source under the Apache 2.0 license. MongoDB also offers Realm Sync with cloud synchronization features under a commercial license.
How does @ObservedResults work with SwiftUI?
@ObservedResults monitors a specific Realm object type and provides a Results collection that automatically updates when objects are added, modified, or removed. The $ binding enables direct mutations through SwiftUI's standard interaction patterns like onDelete.
Conclusion
RealmSwift provides a powerful yet approachable database solution for iOS developers who want to focus on building features rather than managing persistence complexity. Its Swift-native API using the modern @Persisted property wrapper, excellent SwiftUI integration through @ObservedResults, and strong performance characteristics make it an excellent choice for applications ranging from simple utility apps to complex enterprise solutions.
The journey from basic CRUD operations to production-ready implementations involves understanding thread safety, migration strategies, and performance optimization techniques. These advanced topics, while initially complex, become intuitive with practice and enable the development of robust applications that scale from prototype to millions of users. As mobile applications continue to demand ever-higher performance and richer data experiences, RealmSwift's architectural advantages position it as an increasingly important tool in the mobile developer's toolkit.
For teams evaluating mobile development frameworks, understanding the pros and cons of different app development approaches can help you choose the right technology stack for your project requirements.