Diego Freniche

Review of existing and supported Realm Data Types for the different SDKs.

Realm Data Types

Realm GraphQL Demo: Custom Resolvers

Realm Series

Nic Raboy

Learn how to build a space shooter game that synchronizes between clients and the cloud using MongoDB, Unity, and Realm Sync.

Building a Space Shooter Game that Syncs with Unity and MongoDB Realm

Dominic Frei

This article shows how to integrate the Realm Unity SDK into your Unity game. We will cover everything you need to know to get started: installing the SDK, defining your models, and connecting the database to your GameObjects.

Persistence in Unity Using Realm

Mohit Sharma

> This is a follow-up article in the **[Getting Started Series](https://www.mongodb.com/developer/how-to/introduction-realm-sdk-android/)**.
> In this article, we learn how to modify/migrate Realm **local** database schema.

## Introduction

As you add and change application features, you need to modify database schema, and the need for
migrations arises, which is very important for a seamless user experience.

By the end of this article, you will learn:

1. How to update database schema post-production release on play store.
2. How to migrate user data from one schema to another.

Before we get down to business, let's quickly recap how we set `Realm` in our application.

```kotlin
const val REALM_SCHEMA_VERSION: Long = 1
const val REALM_DB_NAME = "rMigrationSample.db"

fun setupRealm(context: Context) {
    Realm.init(context)

    val config = RealmConfiguration.Builder()
        .name(REALM_DB_NAME)
        .schemaVersion(REALM_SCHEMA_VERSION)
        .build()

    Realm.setDefaultConfiguration(config)
}
```

Doing migration in Realm is very straightforward and simple. The high-level steps for the successful
migration of any database are:

1. Update the database version.
2. Make changes to the database schema.
3. Migrate user data from old schema to new.

## Update the Database Version

This is the simplest step, which can be done by incrementing the version of
`REALM_SCHEMA_VERSION`, which notifies `Relam` about database changes. This, in turn, runs triggers
migration, if provided.

To add migration, we use the `migration` function available in `RealmConfiguration.Builder`, which
takes an argument of `RealmMigration`, which we will review in the next step.

```kotlin
val config = RealmConfiguration.Builder()
    .name(REALM_DB_NAME)
    .schemaVersion(REALM_SCHEMA_VERSION)
    .migration(DBMigrationHelper())
    .build()
```

## Make Changes to the Database Schema

In `Realm`, all the migration-related operation has to be performed within the scope
of `RealmMigration`.

```kotlin
class DBMigrationHelper : RealmMigration {

    override fun migrate(realm: DynamicRealm, oldVersion: Long, newVersion: Long) {
        migration1to2(realm.schema)
        migration2to3(realm.schema)
        migration3to4(realm.schema)
    }

    private fun migration3to4(schema: RealmSchema?) {
        TODO("Not yet implemented")
    }

    private fun migration2to3(schema: RealmSchema?) {
        TODO("Not yet implemented")
    }

    private fun migration1to2(schema: RealmSchema) {
        TODO("Not yet implemented")
    }
}
```

To add/update/rename any field:

```kotlin

private fun migration1to2(schema: RealmSchema) {
    val userSchema = schema.get(UserInfo::class.java.simpleName)
    userSchema?.run {
        addField("phoneNumber", String::class.java, FieldAttribute.REQUIRED)
        renameField("phoneNumber", "phoneNo")
        removeField("phoneNo")
    }
}
```

## Migrate User Data from Old Schema to New

All the data transformation during migration can be done with `transform` function with the help
of `set` and `get` methods.

```kotlin

private fun migration2to3(schema: RealmSchema) {
    val userSchema = schema.get(UserInfo::class.java.simpleName)
    userSchema?.run {
        addField("fullName", String::class.java, FieldAttribute.REQUIRED)
        transform {
            it.set("fullName", it.get<String>("firstName") + it.get<String>("lastName"))
        }
    }
}
```

In the above snippet, we are setting the default value of **fullName** by extracting the value from
old data, like **firstName** and **lastName**.

We can also use `transform` to update the data type.

```kotlin

val personSchema = schema!!["Person"]

// Change type from String to int
schema["Pet"]?.run {
    addField("type_tmp", Int::class.java)
    transform { obj ->
        val oldType = obj.getString("type")
        if (oldType == "dog") {
            obj.setLong("type_tmp", 1)
        } else if (oldType == "cat") {
            obj.setInt("type_tmp", 2)
        } else if (oldType == "hamster") {
            obj.setInt("type_tmp", 3)
        }
    }
    removeField("type")
    renameField("type_tmp", "type")
}
```

In case you want to delete the complete `Realm`, you can use `deleteRealmIfMigrationNeeded` with
`RealmConfiguration.Builder`, but that should be considered as the last resort.

Thank you for reading! If you have any queries or comments, you can share them on
the [MongoDB Realm forum](https://www.mongodb.com/community/forums/c/realm/9) or tweet
me [@codeWithMohit](http://twitter.com/codeWithMohit).

In the next article, we will discuss how to migrate the Realm database with sync.

If you have an iOS app, do check out the iOS tutorial
on [Realm iOS Migration](https://www.mongodb.com/developer/how-to/realm-schema-migration/). 

In this article, we explore and learn how to make Realm SDK database schema changes. 

How to Update Realm SDK Database Schema for Android


<div class="introduction">

In this video, Dominic Frei, iOS engineer on the Realm team, will
introduce you to the Realm SDK for Unity3D. He will be showing you how
to integrate and use the SDK based on a Unity example created during the
video so that you can follow along.

The video is separated into the following sections:  
-   What is Realm and where to download it?
-   Creating an example project
-   Adding Realm to your project
-   Executing simple CRUD operations
-   Recap / Summary

>
>
>Introduction to the Realm SDK for Unity3D
>
>:youtube[]{vid=8jo_S02HLkI}
>
>

For those of you who prefer to read, below we have a full transcript of
the video too. Please be aware that this is verbatim and it might not be
sufficient to understand everything without the supporting video.

>
>
>If you have questions, please head to our [developer community
>website](https://community.mongodb.com/) where the MongoDB engineers and
>the MongoDB community will help you build your next big idea with
>MongoDB.
>
>

</div>

<div class="content">

## Transcript

Hello and welcome to a new tutorial! Today we're not talking about
playing games but rather how to make them. More specifically: how to use
the Realm SDK to persist your data in Unity. I will show you where to
download Realm, how to add it to your project and how to write the
necessary code to save and load your data. Let's get started!

Realm is an open-source, cross-platform database available for many
different platforms. Since we will be working with Unity we'll be using
the Realm .NET SDK. This is not yet available through the Unity package
manager so we need to download it from the Github repository directly. I
will put a link to it into the description. When you go to Releases you
can find the latest release right on the top of the page. Within the
assets you'll find two Unity files. Make sure to choose the file that
says 'unity.bundle' and download it.

Before we actually start integrating Realm into our Unity project let's
create a small example. I'll be creating it from scratch so that you can
follow along all the way and see how easy it is to integrate Realm into
your project. We will be using the Unity Editor version 2021.2.0a10. We
need to use this alpha version because there is a bug in the current
Unity LTS version preventing Realm from working properly. I'll give it a
name and choose a 2D template for this example.

We won't be doing much in the Unity Editor itself, most of the example
will take place in code. All we need to do here is to add a Square
object. The Square will change its color when we click on it and - as
soon as we add Realm to the project - the color will be persisted to the
database and loaded again when we start the game again. The square needs
to be clickable, therefore we need to add a collider. I will choose a
'Box Collider 2D' in this case. Finally we'll add a script to the
square, call it 'Square' and open the script.

The first thing we're going to do before we actually implement the
square's behaviour is to add another class which will hold our data, the
color of our square. We'll call this 'ColorEntity'. All we need for now
are three properties for the colors red, green and blue. They will be of
type float to match the UnityEngine's color properties and we'll default
them to 0, giving us an initial black color. Back in the Square
MonoBehaviour I'll add a ColorEntity property since we'll need that in
several locations. During the Awake of the Square we'll create a new
ColorEntity instance and then set the color of the square to this newly
created ColorEntity by accessing it's SpriteRenderer and setting it's
color. When we go back to the Unity Editor and enter Play Mode we'll see
a black square.

Ok, let's add the color change. Since we added a collider to the square
we can use the OnMouseDown event to listen for mouse clicks. All we want
to do here is to assign three random values to our ColorEntity. We'll
use Random.Range and clamp it between 0 and 1. Finally we need to update
the square with these colors. To avoid duplicated code I'll grab the
line from Awake where we set the color and put it in it's own function.
Now we just call it in Awake and after every mouse click. Let's have a
look at the result.

Initially we get our default black color. And with every click the color
changes. When I stop and start again, we'll of course end up with the
initial default again since the color is not yet saved. Let's do that
next!

We go to Window, Package Manager. From here we click on the plus icon
and choose 'Add package from tarball'. Now you just have to choose the
tarball downloaded earlier. Keep in mind that Unity does not import the
package and save it within your project but uses exactly this file
wherever it is. If you move it, your project won't work anymore. I
recommend moving this file from your Downloads to the project folder
first. As soon as it is imported you should see it in the Custom section
of your package list. That's all we need to do in the Unity Editor,
let's get back to Visual Studio.

Let's start with our ColorEntity. First, we want to import the Realm
package by adding 'using Realms'. The way Realm knows which objects are
meant to be saved in the database is by subclassing 'RealmObjects'.
That's all we have to do here really. To make our life a little bit
easier though I'll also add some more things. First, we want to have a
primary key by which we can later find the object we're looking for
easily. We'll just use the 'ObjectName' for that and add an attribute on
top of it, called 'PrimaryKey'. Next we add a default initialiser to
create a new Realm object for this class and a convenience initialiser
that sets the ObjectName right away. Ok, back to our Square. We need to
import Realm here as well. Then we'll create a property for the Realm
itself. This will later let us access our database. And all we need to
do to get access to it is to instantiate it. We'll do this during awake
as well, since it only needs to be done once.

Now that we're done setting up our Realm we can go ahead and look at how
to perform some simple CRUD operations. First, we want to actually
create the object in the database. We do this by calling add. Notice
that I have put this into a block that is passed to the write function.
We need to do this to tell our Realm that we are about to change data.
If another process was changing data at the same time we could end up in
a corrupt database. The write function makes sure that every other
process is blocked from writing to the database at the time we're
performing this change.

Another thing I'd like to add is a check if the ColorEntity we just
created already exists. If so, we don't need to create it again and in
fact can't since primary keys have to be unique. We do this by asking
our Realm for the ColorEntity we're looking for, identified by it's
primary key. I'll just call it 'square' for now. Now I check if the
object could be found and only if not, we'll be creating it with exactly
the same primary key. Whenever we update the color and therefore update
the properties of our ColorEntity we change data in our database.
Therefore we also need to wrap our mouse click within a write block.
Let's see how that looks in Unity. When we start the game we still see
the initial black state. We can still randomly update the color by
clicking on the square. And when we stop and start Play Mode again, we
see the color persists now.

Let's quickly recap what we've done. We added the Realm package in Unity
and imported it in our script. We added the superclass RealmObject to
our class that's supposed to be saved. And then all we need to do is to
make sure we always start a write transaction when we're changing data.
Notice that we did not need any transaction to actually read the data
down here in the SetColor function.

Alright, that's it for this tutorial. I hope you've learned how to use
Realm in your Unity project to save and load data.

</div>

<div class="summary">

>
>
>If you have questions, please head to our [developer community
>website](https://community.mongodb.com/) where the MongoDB engineers and
>the MongoDB community will help you build your next big idea with
>MongoDB.
>
>

</div>


In this video, Dominic Frei, iOS engineer on the Realm team, will introduce you to the Realm SDK for Unity3D

Introduction to the Realm SDK for Unity3D

Lubo Blagoev



<div class="introduction">

Recently, the Realm JavaScript team has reimplemented the Realm JS
Node.js SDK from the ground up to use
[N-API](https://nodejs.org/api/n-api.html#n_api_n_api). In this post, we
describe the need to migrate to N-API because of breaking changes in the
JavaScript Virtual Machine and how we approached it in an iterative way.

</div>

<div class="content">

## HISTORY

[Node.js](https://nodejs.org/en/) and
[Electron](https://www.electronjs.org/) are supported platforms for the
[Realm JS SDK](https://docs.mongodb.com/realm/node/install/). Our
embedded library consists of a JavaScript library and a native code
Node.js addon that interacts with the Realm Database native code. This
provides the database functionality to the JS world. It interacts with
the V8 engine, which is the JavaScript virtual machine used in Node.js
that executes the JavaScript user code.

There are different ways to write a Node.js addon. One way is to use the
V8 APIs directly. Another is to use an abstraction layer that hides the
V8 specifics and provides a stable API across versions of Node.js.

The JavaScript V8 virtual machine is a moving target. Its APIs are
constantly changing between versions. Some are deprecated, and new APIs
are introduced all the time. Previous versions of Realm JS used
[NAN](https://www.npmjs.com/package/nan) to interact with the V8 virtual
machine because we wanted to have a more stable layer of APIs to
integrate with.

While useful, this had its drawbacks since NAN also needed to handle
deprecated V8 APIs across versions. And since NAN integrates tightly
with the V8 APIs, it did not shield us from the virtual machine changes
underneath it. In order to work across the different Node.js versions,
we needed to create a native binary for every major Node.js version.
This sometimes required major effort from the team, resulting in delayed
releases of Realm JS for a new Node.js version.

The changing VM API functionality meant handling the deprecated V8
features ourselves, resulting in various version checks across the code
base and bugs, when not handled in all places.

There were many other native addons that have experienced the same
problem. Thus, the Node.js team decided to create a stable API layer
build within Node.js itself, which guarantees API stability across major
Node.js versions regardless of the virtual machine API changes
underneath. This API layer is called
[N-API](https://nodejs.org/api/n-api.html#n_api_n_api). It not only
provides API stability but also guarantees ABI stability. This means
binaries compiled for one major version are able to run on later major
versions of Node.js.

N-API is a C API. To support C++ for writing Node.js addons, there is a
module called
[node-addon-api](https://github.com/nodejs/node-addon-api). This module
is a more efficient way to write code that calls N-API. It provides a
layer on top of N-API. Developers use this to create and manipulate
JavaScript values with integrated exception handling that allows
handling JavaScript exceptions as native C++ exceptions and vice versa.

## N-API Challenges

When we started our move to N-API, the Realm JavaScript team decided
early on that we would build an N-API native module using the
node-addon-api library. This is because Realm JS is written in C++ and
there is no reason not to choose the C++ layer over the pure N-API C
layer.

The motivation of needing to defend against breaking changes in the JS
VM became one of the goals when doing a complete rewrite of the library.
We needed to provide exactly the same behavior that currently exists.
Thankfully, the Realm JS library has an extensive suite of tests which
cover all of the supported features. The tests are written in the form
of integration tests which test the specific user API, its invocation,
and the expected result.

Thus, we didn't need to handle and rewrite fine-grained unit tests which
test specific details of how the implementation is done. We chose this
tack because we could iteratively convert our codebase to N-API, slowly
converting sections of code while running regression tests which
confirmed correct behavior, while still running NAN and N-API at the
same time. This allowed us to not tackle a full rewrite all at once.

One of the early challenges we faced is how we were going to approach
such a big rewrite of the library. Rewriting a library with a new API
while at the same time having the ability to test as early as possible
is ideal to make sure that code is running correctly. We wanted the
ability to perform the N-API migration partially, reimplementing
different parts step by step, while others still remained on the old NAN
API. This would allow us to build and test the whole project with some
parts in NAN and others in N-API. Some of the tests would invoke the new
reimplemented functionality and some tests would be using the old one.

Unfortunately, NAN and N-API diverged too much starting from the initial
setup of the native addon. Most of the NAN code used the `v8::Isolate`
and the N-API code had the opaque structure `Napi::Env` as a substitute
to it. Our initialization code with NAN was using the v8::Isolate to
initialize the Realm constructor in the init function

``` clike
static void init(v8::Local<v8::Object> exports, 
   v8::Local<v8::Value> module, v8::Local<v8::Context> context) {
   v8::Isolate* isolate = context->GetIsolate();
   v8::Local<v8::Function> realm_constructor =        
 js::RealmClass<Types>::create_constructor(isolate);

   Nan::Set(exports, realm_constructor->GetName(), realm_constructor);
   }
NODE_MODULE_CONTEXT_AWARE(Realm, realm::node::init);
```

and our N-API equivalent for this code was going to be

``` clike
static Napi::Object NAPI_Init(Napi::Env env, Napi::Object exports) {
   return exports;
}
NODE_API_MODULE(realm, NAPI_Init)
```

When we look at the code, we can see that we can't call `v8::isolate`,
which we used in our old implementation, from the exposed N-API. The
problem becomes clear: We don't have any access to the `v8::Isolate`,
which we need if we want to invoke our old initialization logic.

Fortunately, it turned out we could just use a hack in our initial
implementation. This enabled us to convert certain parts of our Realm JS
implementation while we continued to build and ship new versions of
Realm JS with parts using NAN. Since `Napi::Env` is just an equivalent
substitute for `v8::Isolate`, we can check if it has a `v8::Isolate`
hiding in it. As it turns out, this is a way to do this - but it's a
private member. We can grab it from memory with

``` clike
napi_env e  =  env;
v8::Isolate* isolate = (v8::Isolate*)e + 3;
```

and our NAPI_init method becomes

``` clike
static Napi::Object NAPI_Init(Napi::Env env, Napi::Object exports) {
//NAPI: FIXME: remove when NAPI complete
    napi_env e  =  env;
    v8::Isolate* isolate = (v8::Isolate*)e + 3;
  //the following two will fail if isolate is not found at the expected location
     auto currentIsolate = isolate->GetCurrent();
     auto context = currentIsolate->GetCurrentContext();
   //

   realm::node::napi_init(env, currentIsolate, exports);
    return exports;
}
```

Here, we invoke two functions — `isolate->GetCurrent()` and
`isolate->GetCurrentContext()` — to verify early on that the pointer to
the `v8::Isolate` is correct and there are no crashes.

This allowed us to extract a simple function which can return a
`v8::Isolate` from the `Napi::Env` structure any time we needed it. We
continued to switch all our function signatures to use the new
`Napi::Env` structure, but the implementation of these functions could
be left unchanged by getting the `v8::Isolate` from `Napi::Env` where
needed. Not every NAN function of Realm JS could be reimplemented this
way but still, this hack allowed for an easy process by converting the
function to NAPI, building and testing. It then gave us the freedom to
ship a fully NAPI version without the hack once we had time to convert
the underlying API to the stable version.

</div>

<div class="summary">

## What We Learned

Having the ability to build the entire project early on and then even
run it in hybrid mode with NAN and N-API allowed us to both refactor and
continue to ship net new features. We were able to run specific tests
with the new functionality while the other parts of the library remained
untouched. Being able to build the project is more valuable than
spending months reimplementing with the new API, only then to discover
something is not right. As the saying goes, "Test early, fail fast."

Our experience while working with N-API and node-addon-api was positive.
The API is easy to use and reason. The integrated error handling is of a
great benefit. It catches JS exceptions from JS callbacks and rethrows
them as C++ exceptions and vice versa. There were some quirks along the
way with how node-addon-api handled allocated memory when exceptions
were raised, but we were easily able to overcome them. We have submitted
PRs for some of these fixes to the node-addon-api library.

Recently, we flipped the switch to one of the major features we gained
from N-API - the build system release of the Realm JS native binary.
Now, we build and release a single binary for every Node.js major
version.

When we finished, the Realm JS with N-API implementation resulted in
much cleaner code than we had before and our test suite was green. The
N-API migration fixed some of the major issues we had with the previous
implementation and ensures our future support for every new major
Node.js version.

For our community, it means a peace of mind that Realm JS will continue
to work regardless of which Node.js or Electron version they are working
with - this is the reason why the Realm JS team chose to replatform on
N-API.

To learn more, ask questions, leave feedback, or simply connect with
other MongoDB developers, visit our [community
forums.](https://developer.mongodb.com/community/forums/) Come to learn.
Stay to connect.

>
>
>To get started with RealmJS, visit our [GitHub
>Repo](https://github.com/realm/realm-js). Getting started with Atlas is
>also easy. Sign up for a [free MongoDB
>Atlas](https://mongodb.com/cloud/atlas) account to start working with
>all the exciting new features of MongoDB, including Realm and Charts,
>today!
>
>

</div>


The Realm JavaScript team has reimplemented the Realm JS Node.js SDK from the ground up to use N-API. Here we describe how and why.

How We Migrated Realm JavaScript From NAN to N-API

Ian Ward

Today, we are pleased to announce the next installment of the Realm Flutter SDK – now with support for Windows, macOS, iOS, and Android. This release gives you the ability to use Realm in any of your Flutter or Dart projects regardless of the version. 

Realm is a simple super-fast, object-oriented database for mobile applications that does not require an ORM layer or any glue code to work with your data layer. With Realm, working with your data is as simple as interacting with objects from your data model. Any updates to the underlying data store will automatically update your objects as soon as the state on disk has changed, enabling you to automatically refresh the view via StatefulWidgets and Streams.

## Introduction 

Flutter has been a boon to developers across the globe, a framework designed for all platforms: iOS, Android, server and desktop. It enables a developer to write code once and deploy to multiple platforms. Optimizing for performance across multiple platforms that use different rendering engines and creating a single hot reload that work across all platforms is not an easy feat, but the Flutter and Dart teams have done an amazing job. It’s not surprising therefore that Flutter support is our top request on Github.

Realm’s Core Database is platform independent meaning it is easily transferable to another environment which has enabled us to build SDKs for the most popular mobile development frameworks: iOS with Swift, Android with Kotlin, React Native, Xamarin, Unity, and now Flutter.

Our initial version of the Flutter SDK was tied to a custom-built Flutter engine. It was version-specific and shipped as a means to gather feedback from the community on our Realm APIs. With this latest version, we worked closely with the Flutter and Dart team to integrate with the Dart FFI APIs. Now, developers can use Realm with any version of their Dart or Flutter projects. More importantly though, this official integration will form the underpinning of all our future releases and includes full support from Dart’s null safety functionality. Moving forward, we will continue to closely partner with the Flutter and Dart team to follow best practices and ensure version compatibility. 

## Why Realm

All of Realm’s SDKs are built on three core concepts:

* An object database that infers the schema from the developers’ class structure – making working with objects as easy as interacting with their data layer. No conversion code necessary
* Live objects so the developer has a simple way to update their UI – integrated with StatefulWidgets and Streams
* A columnar store so that query results return in lightning speed and directly integrate with an idiomatic query language the developer prefers

Realm is a database designed for mobile applications as a replacement for SQLite. It was written from the ground up in C++, so it is not a wrapper around SQLite or any other relational datastore. Designed with the mobile environment in mind, it is lightweight and optimizes for constraints like compute, memory, bandwidth, and battery that do not exist on the server side. Realm uses lazy loading and memory mapping with each object reference pointing directly to the location on disk where the state is stored. This exponentially increases lookup and query speed as it eliminates the loading of state pages of disk space into memory to perform calculations. It also reduces the amount of memory pressure on the device while working with the data layer. 

## Realm for Flutter Developers

Since Realm is an object database, your schema is defined in the same way you define your object classes. Additionally, Realm delivers a simple and intuitive string-based query system that will feel natural to Flutter developers. No more context switching to SQL to instantiate your schema or looking behind the curtain when an ORM fails to translate your calls into SQL. And because Realm object’s are memory-mapped, a developer can bind an object or query directly to the UI. As soon as changes are made to the state store, they are immediately reflected in the UI. No need to write complex logic to continually recheck whether a state change affects objects or queries bound to the UI and therefore refresh the UI. Realm updates the UI for you.

```cs  
// Import the Realm package and set your app file name
import 'package:realm_dart/realm.dart';

part 'test.g.dart'; // if this is test.dart

// Set your schema
@RealmModel()
class _Task {
  late String name;
  late String owner;
  late String status;
}

void main(List<String> arguments) {
  // Open a realm database instance. Be sure to run the Realm generator to generate your schema
  var config = Configuration([Task.schema]);
  var realm = Realm(config);

  // Create an instance of your Tasks object and persist it to disk
  var task = Task("Ship Flutter", "Lubo", "InProgress");
  realm.write(() {
    realm.add(task);
  });

  // Use a string to based query language to query the data
  var myTasks = realm.all<Task>().query("status == 'InProgress'");

  var newTask = Task("Write Blog", "Ian", "InProgress");
  realm.write(() {
    realm.add(newTask);
  });

  // Queries are kept live and auto-updating - the length here is now 2
  myTasks.length;
}
```
## Looking Ahead

The Realm Flutter SDK is free, open source and available for you to try out today. While this release is still in Alpha, our development team has done a lot of the heavy lifting to set a solid foundation – with a goal of moving rapidly into Beta and GA later this year. We will look to bring new notification APIs, a migration API, solidify our query system, helper functions for Streams integration, and of course Realm Sync to automatically replicate data to MongoDB Atlas. 

Give it a try today and let us know what you [think!](http://forums.realm.io) Check out our [samples](https://github.com/realm/realm-dart-samples), read our [docs](https://docs.mongodb.com/realm/sdk/flutter/), and follow our [repo](https://github.com/realm/realm-dart).


Announcing the next installment of the Realm Flutter SDK – now with support for Windows, macOS, iOS, and Android.

SDK

Featured

Introducing the Realm Flutter SDK

Introduction to the Realm SDK for Unity3D

How We Migrated Realm JavaScript From NAN to N-API

All SDK Content