Programming language: Swift
License: MIT License
Tags: Database    
Latest version: v1.3.0

RealmWrapper alternatives and similar libraries

Based on the "Database" category.
Alternatively, view RealmWrapper alternatives based on common mentions on social networks and blogs.

Do you think we are missing an alternative of RealmWrapper or a related project?

Add another 'Database' Library



Cocoapods Carthage compatible Swift GitHub license Build Status

RealmWrapper is wrapper library for RealmSwift in realm-cocoa

If you use RealmWrapper, you can easily use UI update through Notification and Transaction processing. Also, you do not have to worry about the retain cycle when using self in the Notification block.

At a Glance

If you use RealmSwift, you have to be careful about try statement and thread processing every transaction. However, In RealmManageable which manages one realm file, transaction processing is performed using Realm-only DispatchQueue. RealmProxiable, which owns RealmManageable, can easily add, modify or delete models without having to worry about try statement and thread processing.

User Model

class User: Object {
    dynamic var id: String?
    dynamic var name: String?
override static func primaryKey() -> String? {
    return "id"


var user = User() user.id = UUID().uuidString user.name = "Kevin"

> Using RealmSwift
let realm = try! Realm(configuration: Realm.Configuration(fileURL: URL(fileURLWithPath: RLMRealmPathForFile("user.realm")), schemaVersion: 1, objectTypes: [User.self]))
try! realm.write {

Using RealmWrapper

UserRealmManager().transaction(writeHandler: { (realm) in


  • By default, you can use the transaction function to process a Realm Transaction in MainThread

    UserRealmManager().transaction(writeHandler: { (realm) in
  • It can be implemented by a background thread using DispatchQueue and isSync parameters.

    UserRealmManager().transaction(isSync: false, writeHandler: { (realm) in
UserRealmManager().transaction(writeQueue: DispatchQueue(label: "background"), isSync: false, writeHandler: { (realm) in
  • You can add completion closure. swift UserRealmManager().transaction(isSync: false, writeHandler: { (realm) in realm.add(user) }) { (realm, error) in self.tableView.reloadData() }

Getting Started

  1. Create a RealmManager that manages one realm file.
final class UserRealmManager: RealmManageable {

    var isUseInMemory: Bool {
        return false
    var schemaVersion: UInt64 {
        return 1
    var fileName: String {
        return "user"
    var objectTypes: [Object.Type]? {
        return [User.self]

  1. Create a RealmProxy that is responsible for the CRUD function to be accessed by the Controller.
struct UserRealmProxy<RealmManager: UserRealmManager>: RealmProxiable {

    var users: RealmQuery<User> {
        return query(sortProperty: "date", ordering: .ascending)

    func append(_ user: User) {
        rm.transaction(writeHandler: { (realm) in
            realm.add(user, update: .all)

    func delete(_ user: User) {
        rm.transaction(writeHandler: { (realm) in

    func updateName(id: String, name: String, age: Int) {
        guard let user = userFromId(id) else {return}

        rm.transaction(writeHandler: { (realm) in
            user.name = name
            user.age = age
            realm.add(user, update: .all)

    func userFromId(_ id: String) -> User? {
        return query(filter: "id == '\(id)'").results.first


var user = User()
user.id = UUID().uuidString
user.name = "Kevin"

UserRealmProxy().updateName(id: user.id, name: "Kris")
  1. If you want to register the notification of the status of the Realm object in the controller, you can register the notification in RealmQuery.
let users: RealmQuery<User> = UserRealmProxy().users

    .addInsertNotificationBlock(self) { (self, insertions) in
    .addModificateNotificationBlock(self) { (self, modifications) in
        self.tableView.reloadRows(at: modifications, with: .fade)
    .addDeleteNotificationBlock(self) { (self, deletions) in
        self.tableView.deleteRows(at: deletions, with: .fade)

Also, since RealmQuery is doing weak handling to prevent the retain cycle, you can use closures without worrying about the retain cycle if you pass only self.

public func addDeleteNotificationBlock<Object: AnyObject>(_ object: Object, block: @escaping (Object, [IndexPath]) -> Void) -> Self {
    deleteNotificationBlock = { [weak object] (deletions) in
        guard let weakObject = object else {return}

        block(weakObject, deletions)

    return self


RealmManageable Property

Property Type Default Description
isUseInMemory Bool required Use InMemory Realm
fileName Bool required Realm File Name
appGroupIdentifier String? nil Value for Realm file directory for App Extension


  1. run carthage update

    $ carthage update --platform iOS
  2. open RealmWrapper.xcodeproj

    $ open RealmWrapper.xcodeproj
  3. run RealmWrapperExample


CocoaPods (iOS 9+)

platform :ios, '9.0'

target '<Your Target Name>' do
    pod 'RealmWrapper'

Carthage (iOS 9+)

github "k-lpmg/RealmWrapper"


These works are available under the MIT license. See the [LICENSE][license] file for more info.

*Note that all licence references and agreements mentioned in the RealmWrapper README section above are relevant to that project's source code only.