Enhancements

• Flexible sync subscription state will change to SyncSubscriptionState.pending (RLMSyncSubscriptionStatePending) while waiting for the server to have sent all pending history after a bootstrap and before marking a subscription as Complete. (#5795)
• Add custom column names API, which allows to set a different column name in the realm from the one used in your object declaration.

  class Person: Object {
      @Persisted var firstName: String
      @Persisted var birthDate: Date
      @Persisted var age: Int
  
      override class public func propertiesMapping() -> [String: String] {
          ["firstName": "first_name",
           "birthDate": "birth_date"]
      }
  }
  

  This is very helpful in cases where you want to name a property differently from your Device Sync JSON schema. This API is only available for old and modern object declaration syntax on the RealmSwift SDK.

• Flexible sync bootstraps now apply 1MB of changesets per write transaction rather than applying all of them in a single write transaction. (Core PR #5999).

Fixed

• Fix a race condition which could result in "operation cancelled" errors being delivered to async open callbacks rather than the actual sync error which caused things to fail (Core PR #5968, since the introduction of async open).
• Fix database corruption issues which could happen if an application was terminated at a certain point in the process of comitting a write transaciton. (Core PR #5993, since v10.21.1)
• @AsyncOpen and @AutoOpen would begin and then cancel a second async open operation (PR #8038, since v10.12.0).
• Changing the search text when using the searchable SwiftUI extension would trigger multiple updates on the View for each change (PR #8038, since v10.19.0).
• Changing the filter or search properties of an @ObservedResults or @ObservedSectionedResults would trigger up to three updates on the View (PR #8038, since v10.6.0).
• Fetching a user's profile while the user logs out would result in an assertion failure. (Core PR #6017, since v10.8.0)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 14.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14.1.

Internal

• Upgraded realm-core from 12.11.0 to 12.13.0

Fixed

• Fix name lookup errors when importing Realm Swift built in library evolution mode ((#8014).
• The prebuilt watchOS library in the objective-c release package was missing an arm64 slice. The Swift release package was uneffected (PR #8016).
• Fix issue where RLMUserAPIKey.key/UserAPIKey.key incorrectly returned the name of the API key instead of the key itself. (#8021, since v10.0.0)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 14.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14.1.

Switch to building the Carthage release with Xcode 14.1.

Fixed

• Fix linker errors when building a release build with Xcode 14.1 when installing via SPM (#7995).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 14.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14.1.

Enhancements

• Improve performance of client reset with automatic recovery and converting top-level tables into embedded tables (Core #5897).
• Realm.Error is now a typealias for RLMError rather than a manually-defined version of what the automatic bridging produces. This should have no effect on existing working code, but the manual definition was missing a few things supplied by the automatic bridging.
• Some sync errors sent by the server include a link to the server-side logs associated with that error. This link is now exposed in the serverLogURL property on SyncError (or RLMServerLogURLKey userInfo field when using NSError).

Fixed

• Many sync and app errors were reported using undocumented internal error codes and/or domains and could not be programmatically handled. Some notable things which now have public error codes instead of unstable internal ones:
  • Realm.Error.subscriptionFailed: The server rejected a flexible sync subscription.
  • AppError.invalidPassword: A login attempt failed due to a bad password.
  • AppError.accountNameInUse: A registration attempt failed due to the account name being in use.
  • AppError.httpRequestFailed: A HTTP request to Atlas App Services completed with an error HTTP code. The failing code is available in the httpStatusCode property.
  • Many other less common error codes have been added to AppError.
  • All sync errors other than SyncError.clientResetError reported incorrect error codes. (since v10.0.0).
• UserAPIKey.objectId was incorrectly bridged to Swift as RLMObjectId to ObjectId. This may produce warnings about an unneccesary cast if you were previously casting it to the correct type (since v10.0.0).
• Fixed an assertion failure when observing change notifications on a sectioned result, if the first modification was to a linked property that did not cause the state of the sections to change. (Core #5912, since the introduction of sectioned results in v10.29.0)
• Fix a use-after-free if the last external reference to an encrypted synchronized Realm was closed between when a client reset error was received and when the download of the new Realm began. (Core #5949, since 10.28.4).
• Fix an assertion failure during client reset with recovery when recovering a list operation on an embedded object that has a link column in the path prefix to the list from the top level object. (Core #5957, since introduction of automatic recovery in v10.32.0).
• Creating a write transaction which is rejected by the server due to it exceeding the maximum transaction size now results in a client reset error instead of synchronization breaking and becoming stuck forever (Core #5209, since v10).
• Opening an unencrypted file with an encryption key would sometimes report a misleading error message that indicated that the problem was something other than a decryption failure (Core #5915, since 0.89.0).
• Fix a rare deadlock which could occur when closing a synchronized Realm immediately after committing a write transaction when the sync worker thread has also just finished processing a changeset from the server (Core #5948).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 14.0.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14.1.

Internal

• Upgraded realm-core from 12.9.0 to 12.11.0.

Enhancements

• Add .recoverUnsyncedChanges (RLMClientResetModeRecoverUnsyncedChanges) and .recoverOrDiscardUnsyncedChanges (RLMClientResetModeRecoverOrDiscardUnsyncedChanges) behaviors to ClientResetMode (RLMClientResetMode).
  • The newly added recover modes function by downloading a realm which reflects the latest state of the server after a client reset. A recovery process is run locally in an attempt to integrate the server state with any local changes from before the client reset occurred. The changes are integrated with the following rules:
    1. Objects created locally that were not synced before client reset, will be integrated.
    2. If an object has been deleted on the server, but was modified on the client, the delete takes precedence and the update is discarded.
    3. If an object was deleted on the client, but not the server, then the client delete instruction is applied.
    4. In the case of conflicting updates to the same field, the client update is applied.
  • The client reset process will fallback to ClientResetMode.discardUnsyncedChanges if the recovery process fails in .recoverOrDiscardUnsyncedChanges.
  • The client reset process will fallback to ClientResetMode.manual if the recovery process fails in .recoverUnsyncedChanges.
  • The two new swift recovery modes support client reset callbacks: .recoverUnsyncedChanges(beforeReset: ((Realm) -> Void)? = nil, afterReset: ((Realm, Realm) -> Void)? = nil).
  • The two new Obj-C recovery modes support client reset callbacks in notifyBeforeReset and notifyAfterResetfor both [RLMUser configurationWithPartitionValue] and [RLMUser flexibleSyncConfigurationWithClientResetMode] For more detail on client reset callbacks, see ClientResetMode, RLMClientResetBeforeBlock, RLMClientResetAfterBlock, and the 10.25.0 changelog entry.
• Add two new additional interfaces to define a manual client reset handler:
  • Add a manual callback handler to ClientResetMode.manual -> ClientResetMode.manual(ErrorReportingBlock? = nil).
  • Add the RLMSyncConfiguration.manualClientResetHandler property (type RLMSyncErrorReportingBlock).
  • These error reporting blocks are invoked in the event of a RLMSyncErrorClientResetError.
  • See ErrorReportingBlock (RLMSyncErrorReportingBlock), and ClientResetInfo for more detail.
  • Previously, manual client resets were handled only through the SyncManager.ErrorHandler. You have the option, but not the requirement, to define manual reset handler in these interfaces. Otherwise, the SyncManager.ErrorHandler is still invoked during the manual client reset process.
  • These new interfaces are only invoked during a RLMSyncErrorClientResetError. All other sync errors are still handled in the SyncManager.ErrorHandler.
  • See 'Breaking Changes' for information how these interfaces interact with an already existing SyncManager.ErrorHandler.

Breaking Changes

• The default clientResetMode (RLMClientResetMode) is switched from .manual (RLMClientResetModeManual) to .recoverUnsyncedChanges (RLMClientResetModeRecoverUnsyncedChanges).
  • If you are currently using .manual and continue to do so, the only change you must explicitly make is designating manual mode in your Realm.Configuration.SyncConfigurations, since they will now default to .recoverUnsyncedChanges.
  • You may choose to define your manual client reset handler in the newly introduced manual(ErrorReportingBlock? = nil) or RLMSyncConfiguration.manualClientResetHandler, but this is not required. The SyncManager.errorHandler will still be invoked during a client reset if no callback is passed into these new interfaces.

Deprecations

• ClientResetMode.discardLocal is deprecated in favor of ClientResetMode.discardUnsyncedChanges. The reasoning is that the name better reflects the effect of this reset mode. There is no actual difference in behavior.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 14.0.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14.1.

The prebuilt binary for Carthage is now build with Xcode 14.0.1.

Enhancements

• Cut the runtime of aggregate operations on large dictionaries in half (Core #5864).
• Improve performance of aggregate operations on collections of objects by 2x to 10x (Core #5864). Greatly improve the performance of sorting or distincting a Dictionary's keys or values. The most expensive operation is now performed O(log N) rather than O(N log N) times, and large Dictionaries can see upwards of 99% reduction in time to sort. (Core #5166)
• Add support for changing the deployment location for Atlas Apps. Previously this was assumed to be immutable (Core #5648).
• The sync client will now yield the write lock to other threads which are waiting to perform a write transaction even if it still has remaining work to do, rather than always applying all changesets received from the server even when other threads are trying to write. (Core #5844).
• The sync client no longer writes an unused temporary copy of the changesets received from the server to the Realm file (Core #5844).

Fixed

• Setting a List property with Results no longer throws an unrecognized selector exception (since 10.8.0-beta.2)
• RLMProgressNotificationToken and ProgressNotificationToken now hold a strong reference to the sync session, keeping it alive until the token is deallocated or invalidated, as the other notification tokens do. (#7831, since v2.3.0).
• Results permitted some nonsensical aggregate operations on column types which do not make sense to aggregate, giving garbage results rather than reporting an error (Core #5876, since v5.0.0).
• Upserting a document in a Mongo collection would crash if the document's id type was anything other than ObjectId (since v10.0.0).
• Fix a use-after-free when a sync session is closed and the app is destroyed at the same time (Core #5752, since v10.19.0).

Deprecations

• RLMUpdateResult.objectId has been deprecated in favor of RLMUpdateResult.documentId to support reporting document ids which are not object ids.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 14.0.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14.1.

Internal

• Upgraded realm-core from 12.7.0 to 12.9.0

Fixed

• Incoming links from RealmAny properties were not handled correctly when migrating an object type from top-level to embedded. RealmAny properties currently cannot link to embedded objects. (Core #5796, since 10.8.0).
• Realm.refresh() sometimes did not actually advance to the latest version. It attempted to be semi-non-blocking in a very confusing way which resulted in it sometimes advancing to a newer version that is not the latest version, and sometimes blocking until notifiers are ready so that it could advance to the latest version. This behavior was undocumented and didn't work correctly, so it now always blocks if needed to advance to the latest version. (#7625, since v0.98.0).
• Fix the most common cause of thread priority inversions when performing writes on the main thread. If beginning the write transaction has to wait for the background notification calculations to complete, that wait is now done in a QoS-aware way. (#7902)
• Subscribing to link properties in a flexible sync Realm did not work due to a mismatch between what the client sent and what the server needed. (Core #5409)
• Attempting to use AsymmetricObject with partition-based sync now reports a sensible error much earlier in the process. Asymmetric sync requires using flexible sync. (Core #5691, since 10.29.0).
• Case-insensitive but diacritic-sensitive queries would crash on 4-byte UTF-8 characters (Core #5825, since v2.2.0)
• Accented characters are now handled by case-insensitive but diacritic-sensitive queries. (Core #5825, since v2.2.0)

Breaking Changes

• -[RLMASLoginDelegate authenticationDidCompleteWithError:] has been renamed to -[RLMASLoginDelegate authenticationDidFailWithError:] to comply with new app store requirements. This only effects the obj-c API. (#7945)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1 - 14.

Internal

• Upgraded realm-core from 12.6.0 to 12.7.0

Enhancements

• Add support for asymmetric sync. When a class inherits from AsymmetricObject, objects created are synced unidirectionally to the server and cannot be queried or read locally.

    class PersonObject: AsymmetricObject {
       @Persisted(primaryKey: true) var _id: ObjectId
       @Persisted var name: String
       @Persisted var age: Int
    }

    try realm.write {
       // This will create the object on the server but not locally.
       realm.create(PersonObject.self, value: ["_id": ObjectId.generate(),
                                               "name": "Dylan",
                                               "age": 20])
    }

• Add ability to section a collection which conforms to RealmCollection, RLMCollection. Collections can be sectioned by a unique key retrieved from a keyPath or a callback and will return an instance of SectionedResults/RLMSectionedResults. Each section in the collection will be an instance of ResultsSection/RLMSection which gives access to the elements corresponding to the section key. SectionedResults/RLMSectionedResults and ResultsSection/RLMSection have the ability to be observed.

  class DemoObject: Object {
      @Persisted var title: String
      @Persisted var date: Date
      var firstLetter: String {
          return title.first.map(String.init(_:)) ?? ""
      }
  }
  var sectionedResults: SectionedResults<String, DemoObject>
  // ...
  sectionedResults = realm.objects(DemoObject.self)
      .sectioned(by: \.firstLetter, ascending: true)
  

• Add @ObservedSectionedResults for SwiftUI support. This property wrapper type retrieves sectioned results from a Realm using a keyPath or callback to determine the section key.

  struct DemoView: View {
      @ObservedSectionedResults(DemoObject.self,
                                sectionKeyPath: \.firstLetter) var demoObjects
  
      var body: some View {
          VStack {
              List {
                  ForEach(demoObjects) { section in
                      Section(header: Text(section.key)) {
                          ForEach(section) { object in
                              MyRowView(object: object)
                          }
                      }
                  }
              }
          }
      }
  }
  

• Add automatic handing for changing top-level objects to embedded objects in migrations. Any objects of the now-embedded type which have zero incoming links are deleted, and objects with multiple incoming links are duplicated. This happens after the migration callback function completes, so there is no functional change if you already have migration logic which correctly handles this. (Core #5737).
• Improve performance when a new Realm file connects to the server for the first time, especially when significant amounts of data has been written while offline. (Core #5772)
• Shift more of the work done on the sync worker thread out of the write transaction used to apply server changes, reducing how long it blocks other threads from writing. (Core #5772)
• Improve the performance of the sync changeset parser, which speeds up applying changesets from the server. (Core #5772)

Fixed

• Fix all of the UBSan failures hit by our tests. It is unclear if any of these manifested as visible bugs. (Core #5665)
• Upload completion callbacks were sometimes called before the final step of interally marking the upload as complete, which could result in calling Realm.writeCopy() from the completion callback failing due to there being unuploaded changes. (Core #4865).
• Writing to a Realm stored on an exFAT drive threw the exception "fcntl() with F_BARRIERFSYNC failed: Inappropriate ioctl for device" when a write transaction needed to expand the file. (Core #5789, since 10.27.0)
• Syncing a Decimal128 with big significand could result in a crash. (Core #5728)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 RC.

Internal

• Upgraded realm-core from 12.5.1 to 12.6.0

Enhancements

• Add prebuilt binaries for Xcode 14 to the release package.

Fixed

• Fix archiving watchOS release builds with Xcode 14.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 6.

Fixed

• Fixed an issue where having realm-swift as SPM sub-target dependency leads to missing symbols error during iOS archiving (Core #7645).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 5.

Internal

• Upgraded realm-core from 12.5.0 to 12.5.1

Enhancements

• Improve performance of accessing SubscriptionSet properties when no writes have been made to the Realm since the last access.

Fixed

• A use-after-free could occur if a Realm with audit events enabled was destroyed while processing an upload completion for the events Realm on a different thread. (Core PR #5714)
• Opening a read-only synchronized Realm for the first time via asyncOpen did not set the schema version, which could lead to m_schema_version != ObjectStore::NotVersioned assertion failures later on.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 4.

Internal

• Upgraded realm-core from 12.4.0 to 12.5.0

Enhancements

• Add support for building arm64 watchOS when installing Realm via CocoaPods.
• Reduce the amount of virtual address space used (Core #5645).

Fixed

• Fix some warnings when building with Xcode 14 (Core #5577).
• Fix compilation failures on watchOS platforms which do not support thread-local storage. (#7694, #7695 since v10.21.1)
• Fix a data race when committing a transaction while multiple threads are waiting to begin write transactions. This appears to not have caused any functional problems.
• Fix a data race when writing audit events which could occur if the sync client thread was busy with other work when the event Realm was opened.
• Fix some cases of running out of virtual address space (seen/reported as mmap failures) (Core #5645).
• Audit event scopes containing only write events and no read events would occasionally throw a BadVersion exception when a write transaction was committed (since v10.26.0).
• The client reset callbacks for the DiscardLocal mode would be passed invalid Realm instances if the callback was invoked at a point where the Realm was not otherwise open. (Core #5654, since the introduction of DiscardLocal reset mode in v10.25.0)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 4.

Internal

• Upgraded realm-core from 12.3.0 to 12.4.0.

Enhancements

• Greatly improve the performance of obtaining cached Realm instances in Swift when using a sync configuration.

Fixed

• Add missing initialSubscription and rerunOnOpen to copyWithZone method on RLMRealmConfiguration. This resulted in incorrect values when using RLMRealmConfiguration.defaultConfiguration.
• The sync error handler did not hold a strong reference to the sync session while dispatching the error from the worker thread to the main thread, resulting in the session passed to the error handler being invalid if there were no other remaining strong references elsewhere.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 3.

Fixed

• Using seedFilePath threw an exception if the Realm file being opened already existed (#7840, since v10.26.0).
• The intialSubscriptions callback was invoked every time a Realm was opened regardless of the value of rerunOnOpen and if the Realm was already open on another thread (since v10.28.0).
• Allow using RLMSupport.Swift from RealmSwift's Cocoapods (#6886).
• Fix a UBSan failure when mapping encrypted pages. Fixing this did not change the resulting assembly, so there were probably no functional problems resulting from this (since v5.0.0).
• Improved performance of sync clients during integration of changesets with many small strings (totalling > 1024 bytes per changeset) on iOS 14, and devices which have restrictive or fragmented memory. (Core #5614)
• Fix a data race when opening a flexible sync Realm (since v10.28.0).
• Add a missing backlink removal when assigning null or a non-link value to an AnyRealmValue property which previously linked to an object. This could have resulted in "key not found" exceptions or assertion failures such as mixed.hpp:165: [realm-core-12.1.0] Assertion failed: m_type when removing the destination link object. (Core #5574, since the introduction of AnyRealmValue in v10.8.0)

Compatibility

• Realm Studio: 12.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 2.

Internal

• Upgraded realm-core from 12.1.0 to 12.3.0.

Enhancements

• Add support for Xcode 14. When building with Xcode 14, the minimum deployment target is now iOS 11.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.1.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-14 beta 1.

Enhancements

• Replace mentions of 'MongoDB Realm' with 'Atlas App Services' in the documentation and update appropriate links to documentation.
• Allow adding a subscription querying for all documents of a type in swift for flexible sync.

   try await subscriptions.update {
      subscriptions.append(QuerySubscription<SwiftPerson>(name: "all_people"))
   }

• Add Combine API support for flexible sync beta.
• Add an initialSubscriptions parameter when retrieving the flexible sync configuration from a user, which allows to specify a subscription update block, to bootstrap a set of flexible sync subscriptions when the Realm is first opened. There is an additional optional parameter flag rerunOnOpen, which allows to run this initial subscriptions on every app startup.

    let config = user.flexibleSyncConfiguration(initialSubscriptions: { subs in
        subs.append(QuerySubscription<SwiftPerson>(name: "people_10") {
            $0.age > 10
        })
    }, rerunOnOpen: true)
    let realm = try Realm(configuration: config)

• The sync client error handler will report an error, with detailed info about which object caused it, when writing an object to a flexible sync Realm outside of any query subscription. (#5528)
• Adding an object to a flexible sync Realm for a type that is not within a query subscription will now throw an exception. (#5488).

Fixed

• Flexible Sync query subscriptions will correctly complete when data is synced to the local Realm. (#5553, since v12.0.0)

Breaking Changes

• Rename SyncSubscriptionSet.write to SyncSubscriptionSet.update to avoid confusion with Realm.write.
• Rename SyncSubscription.update to SyncSubscription.updateQuery to avoid confusion with SyncSubscriptionSet.update.
• Rename RLMSyncSubscriptionSet.write to RLMSyncSubscriptionSet.update to align it with swift API.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-13.4.

Internal

• Upgraded realm-core from 12.0.0 to 12.1.0.

Enhancements

• @AsyncOpen/@AutoOpen property wrappers can be used with flexible sync.

Fixed

• When installing via SPM, debug builds could potentially hit an assertion failure during flexible sync bootstrapping. (Core #5527)
• Flexible sync now only applies bootstrap data if the entire bootstrap is received. Previously orphaned objects could result from the read snapshot on the server changing. (Core #5331)
• Partially fix a performance regression in write performance introduced in v10.21.1. v10.21.1 fixed a case where a kernel panic or device's battery dying at the wrong point in a write transaction could potentially result in a corrected Realm file, but at the cost of a severe performance hit. This version adjusts how file synchronization is done to provide the same safety at a much smaller performance hit. (#7740).

Compatibility

• Realm Studio: 11.0.0 or later (but see note below).
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-13.4.

Internal

• Upgraded realm-core from 11.17.0 to 12.0.0.
• Bump the version number for the lockfile used for interprocess synchronization. This has no effect on persistent data, but means that versions of Realm which use pre-12.0.0 realm-core cannot open Realm files at the same time as they are opened by this version. Notably this includes Realm Studio, and v11.1.2 (the latest at the time of this release) cannot open Realm files which are simultaneously open in the simulator.

Xcode 13.1 is now the minimum supported version of Xcode, as Apple no longer allows submitting to the app store with Xcode 12.

Enhancements

• Add Xcode 13.4 binaries to the release package.
• Add Swift API for asynchronous transactions

    try? realm.writeAsync {
        realm.create(SwiftStringObject.self, value: ["string"])
    } onComplete: { error in
        // optional handling on write complete
    }

    try? realm.beginAsyncWrite {
        realm.create(SwiftStringObject.self, value: ["string"])
        realm.commitAsyncWrite()
    }

    let asyncTransactionId = try? realm.beginAsyncWrite {
        // ...
    }
    try! realm.cancelAsyncWrite(asyncTransactionId)

• Add Obj-C API for asynchronous transactions

   [realm asyncTransactionWithBlock:^{
        [StringObject createInRealm:realm withValue:@[@"string"]];
    } onComplete:^(NSError *error) {
        // optional handling
    }];

    [realm beginAsyncWriteTransaction:^{
        [StringObject createInRealm:realm withValue:@[@"string"]];
        [realm commitAsyncWriteTransaction];
    }];

    RLMAsyncTransactionId asyncTransactionId = [realm beginAsyncWriteTransaction:^{
        // ...
    }];
    [realm cancelAsyncTransaction:asyncTransactionId];

• Improve performance of opening a Realm with objectClasses/objectTypes set in the configuration.
• Implement the Realm event recording API for reporting reads and writes on a Realm file to Atlas.

Fixed

• Lower minimum OS version for async login and FunctionCallables to match the rest of the async functions. ([#7791]https://github.com/realm/realm-swift/issues/7791)
• Consuming a RealmSwift XCFramework with library evolution enabled would give the error 'Failed to build module 'RealmSwift'; this SDK is not supported by the compiler' when the XCFramework was built with an older XCode version and is then consumed with a later version. (#7313, since v3.18.0)
• A data race would occur when opening a synchronized Realm with the client reset mode set to discardLocal on one thread at the same time as a client reset was being processed on another thread. This probably did not cause any functional problems in practice and the broken timing window was very tight (since 10.25.0).
• If an async open of a Realm triggered a client reset, the callbacks for discardLocal could theoretically fail to be called due to a race condition. The timing for this was probably not possible to hit in practice (since 10.25.0).
• Calling [RLMRealm freeze]/Realm.freeze on a Realm which had been created from writeCopy would not produce a frozen Realm. (#7697, since v5.0.0)
• Using the dynamic subscript API on unmanaged objects before first opening a Realm or if objectTypes was set when opening a Realm would throw an exception (#7786).
• The sync client may have sent a corrupted upload cursor leading to a fatal error from the server due to an uninitialized variable. (#5460, since v10.25.1)
• Flexible sync would not correctly resume syncing if a bootstrap was interrupted (#5466, since v10.21.1).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.4.
• CocoaPods: 1.10 or later.
• Xcode: 13.1-13.4.

Internal

• Upgraded realm-core from v11.15.0 to v11.17.0

Enhancements

• Replace Xcode 13.3 binaries with 13.3.1 binaries.

Fixed

• List<AnyRealmValue> would contain an invalidated object instead of null when the object linked to was deleted by a difference sync client (Core #5215, since v10.8.0).
• Adding an object to a Set, deleting the parent object of the Set, and then deleting the object which was added to the Set would crash (Core #5387, since v10.8.0).
• Synchronized Realm files which were first created using v10.0.0-beta.3 would be redownloaded instead of using the existing file, possibly resulting in the loss of any unsynchronized data in those files (since v10.20.0).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.3.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3.1.

Internal

• Upgraded realm-core from v11.14.0 to v11.15.0

Fixed

• Fixed various memory corruption bugs when encryption is used caused by not locking a mutex when needed. (#7640, #7659, since v10.21.1)
• Changeset upload batching did not calculate the accumulated size correctly, resulting in “error reading body failed to read: read limited at 16777217 bytes” errors from the server when writing large amounts of data (Core #5373, since 11.13.0).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.3.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3.

Internal

• Upgraded realm-core from v11.13.0 to v11.14.0.

Synchronized Realm files written by this version cannot be opened by older versions of Realm. Existing files will be automatically upgraded when opened.

Non-synchronized Realm files remain backwards-compatible.

Enhancements

• Add ability to use Swift Query syntax in @ObservedResults, which allows you to filter results using the where parameter.
• Add ability to use MutableSet with StateRealmObject in SwiftUI.
• Async/Await extensions are now compatible with iOS 13 and above when building with Xcode 13.3.
• Sync changesets waiting to be uploaded to the server are now compressed, reducing the disk space needed when large write transactions are performed while offline or limited in bandwidth.(Core #5260).
• Added new SyncConfiguration.clientResetMode and RLMSyncConfiguration.clientResetMode properties.
  • The values of these properties will dictate client behavior in the event of a client reset.
  • See below for information on ClientResetMode values.
  • clientResetMode defaults to .manual if not set otherwise.
• Added new ClientResetMode and RLMClientResetMode enums.
  • These enums represent possible client reset behavior for SyncConfiguration.clientResetMode and RLMSyncConfiguration.clientResetMode, respectively.
  • .manual and RLMClientResetModeManual
    • The local copy of the Realm is copied into a recovery directory for safekeeping, and then deleted from the original location. The next time the Realm for that partition value is opened, the Realm will automatically be re-downloaded from MongoDB Realm, and can be used as normal.
    • Data written to the Realm after the local copy of the Realm diverged from the backup remote copy will be present in the local recovery copy of the Realm file. The re-downloaded Realm will initially contain only the data present at the time the Realm was backed up on the server.
    • rlmSync_clientResetBackedUpRealmPath and SyncError.clientResetInfo() are used for accessing the recovery directory.
  • .discardLocal and RLMClientResetDiscardLocal
    • All unsynchronized local changes are automatically discarded and the local state is automatically reverted to the most recent state from the server. Unsynchronized changes can then be recovered in a post-client-reset callback block (See changelog below for more details).
    • If RLMClientResetModeDiscardLocal is enabled but the client reset operation is unable to complete then the client reset process reverts to manual mode.
    • The realm's underlying object accessors remain bound so the UI may be updated in a non-disruptive way.
• Added support for client reset notification blocks for .discardLocal and RLMClientResetDiscardLocal
  • RealmSwift implementation: discardLocal(((Realm) -> Void)? = nil, ((Realm, Realm) -> Void)? = nil)
    • RealmSwift client reset blocks are set when initializing the user configuration

    var configuration = user.configuration(partitionValue: "myPartition", clientResetMode: .discardLocal(beforeClientResetBlock, afterClientResetBlock))
    

    • The before client reset block -- ((Realm) -> Void)? = nil -- is executed prior to a client reset. Possible usage includes:

    let beforeClientResetBlock: (Realm) -> Void = { beforeRealm in
      var recoveryConfig = Realm.Configuration()
        recoveryConfig.fileURL = myRecoveryPath
        do {
          beforeRealm.writeCopy(configuration: recoveryConfig)
            /* The copied realm could be used later for recovery, debugging, reporting, etc. */
        } catch {
            /* handle error */
        }
    }
    

    • The after client reset block -- ((Realm, Realm) -> Void)? = nil) -- is executed after a client reset. Possible usage includes:

    let afterClientResetBlock: (Realm, Realm) -> Void = { before, after in
    /* This block could be used to add custom recovery logic, back-up a realm file, send reporting, etc. */
    for object in before.objects(myClass.self) {
        let res = after.objects(myClass.self)
        if (res.filter("primaryKey == %@", object.primaryKey).first != nil) {
             /* ...custom recovery logic... */
        } else {
             /* ...custom recovery logic... */
        }
    }
    

  • Realm Obj-c implementation: Both before and after client reset callbacks exist as properties on RLMSyncConfiguration and are set at initialization.

      RLMRealmConfiguration *config = [user configurationWithPartitionValue:partitionValue
                                                            clientResetMode:RLMClientResetModeDiscardLocal
                                                          notifyBeforeReset:beforeBlock
                                                           notifyAfterReset:afterBlock];
    

    where beforeBlock is of type RLMClientResetBeforeBlock. And afterBlock is of type RLMClientResetAfterBlock.

Breaking Changes

• Xcode 13.2 is no longer supported when building with Async/Await functions. Use Xcode 13.3 to build with Async/Await functionality.

Fixed

• Adding a Realm Object to a ObservedResults or a collections using StateRealmObject that is managed by the same Realm would throw if the Object was frozen and not thawed before hand.
• Setting a Realm Configuration for @ObservedResults using it's initializer would be overrode by the Realm Configuration stored in .environment(\.realmConfiguration, ...) if they did not match (Cocoa #7463, since v10.6.0).
• Fix searchable component filter overriding the initial filter on @ObservedResults, (since v10.23.0).
• Comparing Results, LinkingObjects or AnyRealmCollection when using Realm via XCFramework would result in compile time errors (Cocoa #7615, since v10.21.0)
• Opening an encrypted Realm while the keychain is locked on macOS would crash (#7438).
• Updating subscriptions while refreshing the access token would crash (Core #5343, since v10.22.0)
• Fix several race conditions in SyncSession related to setting customRequestHeaders while using the SyncSession on a different thread.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.3.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3.

Internal

• Upgraded realm-core from v11.12.0 to v11.13.0

Fixed

• Application would sometimes crash with exceptions like 'KeyNotFound' or assertion "has_refs()". Other issues indicating file corruption may also be fixed by this. The one mentioned here is the one that lead to solving the problem. (Core #5283, since v5.0.0)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.3.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3.

Internal

• Upgraded realm-core from 11.11.0 to 11.12.0

Switch to building the Carthage binary with Xcode 13.3. This release contains no functional changes from 10.24.0.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.3.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3.

Enhancements

• Add ability to use Swift Query syntax in @ObservedResults, which allows you to filter results using the where parameter.

Fixed

• If a list of objects contains links to objects not included in the synchronized partition, collection change notifications for that list could be incorrect (Core #5164, since v10.0.0).
• Adding a new flexible sync subscription could crash with "Assertion failed: !m_unbind_message_sent" in very specific timing scenarios (Core #5149, since v10.22.0).
• Converting floats/doubles into Decimal128 would yield imprecise results (Core #5184, since v10.0.0)
• Using accented characters in class and field names in a synchronized Realm could result in sync errors (Core #5196, since v10.0.0).
• Calling Realm.invalidate() from inside a Realm change notification could result in the write transaction which produced the notification not being persisted to disk (since v10.22.0).
• When a client reset error which results in the current Realm file being backed up and then deleted, deletion errors were ignored as long as the copy succeeded. When this happens the deletion of the old file is now scheduled for the next launch of the app. (Core #5180, since v2.0.0)
• Fix an error when compiling a watchOS Simulator target not supporting Thread-local storage (#7623, since v10.21.0).
• Add a validation check to report a sensible error if a Realm configuration indicates that an in-memory Realm should be encrypted. (Core #5195)
• The Swift package set the linker flags on the wrong target, resulting in linker errors when SPM decides to build the core library as a dynamic library (#7266).
• The download-core task failed if run in an environment without TMPDIR set (#7688, since v10.23.0).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3 beta 3.

Internal

• Upgraded realm-core from 11.9.0 to 11.11.0

Enhancements

• Add Realm.writeCopy(configuration:)/[RLMRealm writeCopyForConfiguration:] which gives the following functionality:
  • Export a local non-sync Realm to be used with MongoDB Realm Sync when the configuration is derived from a sync RLMUser/User.
  • Write a copy of a local Realm to a destination specified in the configuration.
  • Write a copy of a synced Realm in use with user A, and open it with user B.
  • Note that migrations may be required when using a local realm configuration to open a realm file that was copied from a synchronized realm. An exception will be thrown if a Realm exists at the destination.
• Add a seedFilePath option to RLMRealmConfiguration and Configuration. If this option is set then instead of creating an empty Realm, the realm at the seedFilePath will be copied to the fileURL of the new Realm. If a Realm file already exists at the destination path, the seed file will not be copied and the already existing Realm will be opened instead. Note that to use this parameter with a synced Realm configuration the seed Realm must be appropriately copied to a destination with Realm.writeCopy(configuration:)/[RLMRealm writeCopyForConfiguration:] first.
• Add ability to permanently delete a User from a MongoDB Realm app. This can be invoked with User.delete()/[RLMUser deleteWithCompletion:].
• Add NSCopying conformance to RLMDecimal128 and RLMObjectId.
• Add Xcode 13.3 binaries to the release package (and remove 13.0).

Fixed

• Add support of arm64 in Carthage build (#7154
• Adding missing support for IN queries to primitives types on Type Safe Queries.

  let persons = realm.objects(Person.self).where {
    let acceptableNames = ["Tom", "James", "Tyler"]
    $0.name.in([acceptableNames])
  }
  

  (Cocoa #7633, since v10.19.0)

• Work around a compiler crash when building with Swift 5.6 / Xcode 13.3. CustomPersistable's PersistedType must now always be a built-in type rather than possibly another CustomPersistable type as Swift 5.6 has removed support for infinitely-recursive associated types (#7654).
• Fix redundant call to filter on @ObservedResults from searchable component (since v10.19.0).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.3 beta 3.

Enhancements

• Add beta support for flexible sync. See the backend and SDK documentation for more information. Please report any issues with the beta through Github.

Fixed

• UserIdentity metadata table grows indefinitely. (#5152, since v10.20.0)
• We now report a useful error message when opening a sync Realm in non-sync mode or vice-versa.(#5161, since v5.0.0).

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.2.1.

Internal

• Upgraded realm-core from 11.8.0 to 11.9.0

Fixed

• The sync client will now drain the receive queue when a send fails with ECONNRESET, ensuring that any error message from the server gets received and processed. (#5078)
• Schema validation was missing for embedded objects in sets, resulting in an unhelpful error being thrown if a Realm object subclass contained one (since v10.0.0).
• Opening a Realm with a schema that has an orphaned embedded object type performed an extra empty write transaction (since v10.0.0).
• Freezing a Realm with a schema that has orphaned embedded object types threw a "Wrong transactional state" exception (since v10.19.0).
• @sum and @avg queries on Dictionaries of floats or doubles used too much precision for intermediates, resulting in incorrect rounding (since v10.5.0).
• Change the exception message for calling refresh on an immutable Realm from "Continuous transaction through DB object without history information." to "Can't refresh a read-only Realm." (#5061, since v10.8.0).
• Queries of the form "link.collection.@sum = 0" where link is null matched when collection was a List or Set, but not a Dictionary (#5080, since v10.8.0).
• Types which require custom obj-c bridging (such as PersistableEnum or CustomPersistable) would crash with exceptions mentioning __SwiftValue in a variety of places on iOS versions older than iOS 14 (#7604, since v10.21.0)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.2.1.

Internal

• Upgraded realm-core from 11.6.1 to 11.8.0.

Enhancements

• Add metadata property to RLMUserProfile/UserProfile.
• Add class Projection to allow creation of light weight view models out of Realm Objects.

public class Person: Object {
    @Persisted var firstName = ""
    @Persisted var lastName = ""
    @Persisted var address: Address? = nil
    @Persisted var friends = List<Person>()
}

public class Address: EmbeddedObject {
    @Persisted var city: String = ""
    @Persisted var country = ""
}

class PersonProjection: Projection<Person> {
    // `Person.firstName` will have same name and type
    @Projected(\Person.firstName) var firstName
    // There will be the only String for `city` of the original object `Address`
    @Projected(\Person.address.city) var homeCity
    // List<Person> will be mapped to list of firstNames
    @Projected(\Person.friends.projectTo.firstName) var firstFriendsName: ProjectedCollection<String>
}

// `people` will contain projections for every `Person` object in the `realm`
let people: Results<PersonProjection> = realm.objects(PersonProjection.self)

• Greatly improve performance of reading AnyRealmValue and enum types from Realm collections.
• Allow using Swift enums which conform to PersistableEnum as the value type for all Realm collections.
• AnyRealmCollection now conforms to Encodable.
• AnyRealmValue and PersistableEnum values can now be passed directly to an NSPredicate used in a filter() call rather than having to pass the rawValue (the rawValue is still allowed).
• Queries on collections of PersistableEnums can now be performed with where().
• Add support for querying on the rawValue of an enum with where().
• .count is supported for Maps of all types rather than just numeric types in where().
• Add support for querying on the properties of objects contained in dictionaries (e.g. "[email protected] CONTAINS 'a'").
• Improve the error message for many types of invalid predicates in queries.
• Add support for comparing @allKeys to another property on the same object.
• Add Numeric conformance to Decimal128.
• Make some invalid property declarations such as List<AnyRealmValue?> a compile-time error instead of a runtime error.
• Calling .sorted(byKeyPath:) on a collection with an Element type which does not support sorting by keypaths is now a compile-time error instead of a runtime error.
• RealmCollection.sorted(ascending:) can now be called on all non-Object/EmbeddedObject collections rather than only ones where the Element conforms to Comparable.
• Add support for using user-defined types with @Persistable and in Realm collections by defining a mapping to and from a type which Realm knows how to store. For example, URL can be made persistable with:

  extension URL: FailableCustomPersistable {
      // Store URL values as a String in Realm
      public typealias PersistedType = String
      // Convert a String to a URL
      public init?(persistedValue: String) { self.init(string: persistedValue) }
      // Convert a URL to a String
      public var persistableValue: String { self.absoluteString }
  }
  

  After doing this, @Persisted var url: URL is a valid property declaration on a Realm object. More advanced mappings can be done by mapping to an EmbeddedObject which can store multiple values.

Fixed

• Accessing a non object collection inside a migration would cause a crash
• #5633.
• Accessing a Map of objects dynamically would not handle nulled values correctly (since v10.8.0).
• where() allowed constructing some nonsensical queries due to boolean comparisons returning Query<T> rather than Query<Bool> (since v10.19.0).
• @allValues queries on dictionaries accidentally did not require "ANY".
• Case-insensitive and diacritic-insensitive modifiers were ignored when comparing the result of an aggregate operation to another property in a query.
• Object.init(value:) did not allow initializing RLMDictionary<NSString, RLMObject>/Map<String, Object?> properties with null values for map entries (since v10.8.0).
• @ObservedResults did not refresh when changes were made to the observed collection. (since v10.6.0)

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.2.1.

Rebuild 10.20.1 with Xcode 13.2.1 rather than 13.2.0. This version has no changes if you are not using a prebuilt binary for Realm.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.1.
• CocoaPods: 1.10 or later.
• Xcode: 12.4-13.2.1.

Xcode 12.4 is now the minimum supported version of Xcode.

Fixed

• Add missing Indexable support for UUID. (Cocoa #7545, since v10.10.0)

Breaking Changes

• All async functions now require Xcode 13.2 to work around an App Store/TestFlight bug that results in apps built with 13.0/13.1 which do not use libConcurrency but link a library which does crashing on startup.

Compatibility

• Realm Studio: 11.0.0 or later.
• APIs are backwards compatible with all previous releases in the 10.x.y series.
• Carthage release for Swift is built with Xcode 13.2.
• CocoaPods: 1.10 or later.
• Xcode: 12.2-13.2.