Great! Let us know how we are doing and where we can improve the ObjectBox database. The best place for questions is stackoverflow with a tag objectbox. For feedback you can drop us a line here: contact [at] objectbox.io. And of course, if you like what you see, you can star the database repo in your language of choice on GitHub or like us on pub.dev

Did you check the documentation (Flutter Dart, Java / Kotlin, Go, Swift, C/C++, Data Sync)? We try to make our documentation as extensive as possible, but it’ll always be work-in-progress. If you did not find what you need, please post a question on Stack Overflow using the tag [objectbox]. Our team is monitoring this tag.

Please search the issue tracker (Flutter Dart, Java / Kotlin,  Swift, Go, C/C++) for existing bugs. If you do not find it, please open a new issue. It helps us a lot if you can narrow the issue down a bit and have a reproducible example.

We also track features requests on the issue tracker(Flutter Dart, Java Kotlin, Swift, Go, C / C++). Please make sure you do a quick search on the existing issues to check if the feature was requested before. If that is the case, a simple “+1” helps us understand its importance.

We’re a small team and you can help us bin many ways, e.g. by providing feedback, helping others by answering questions on stackoverflow, or release tutorials to the community…. Of course, we also appreciate if you want to contribute code, e.g. to the bindings, developing a new binding, building a conncetor to another databases. Again, options are endless 😉  Last not least: Tweets, shares, and likes are always appreciated a lot too. 🙂

Yes. ObjectBox comes with strong relation support and offers features like “lazy/eager loading” for optimal performance.

It depends. Internally and in the C API, ObjectBox does zero-copy reads. Language objects (Java, Go, Swift) require a single copy only.

No. The objects you get from ObjectBox are plain objects without any strings attached. You are safe to pass them around in threads.

Android (4.0 and above), Linux (64 bit), Windows (64 bit), macOS, iOS, boards like Raspberry Pi. ObjectBox offers several easy-to-use, intuitive native-language APIs: Java, Flutter / Dart, Kotlin, Go, C, C++, and Swift.

Yes, you can ObjectBox run on the desktop/server side. Contact us for details if you are interested in running ObjectBox in client/server mode or containerized!

Yes, you can run the ObjectBox database on any IoT device that runs Linux (or one of the other supported platforms).

If you only do a rename on the language level, ObjectBox will by default remove the old and add a new entity/property. To do a rename, you must specify the UID. Check the language specific docs how to do so.

A nice thing about ObjectBox is that it does not do caching – it delegates that to the operating system. The OS usually knows very well how to optimize memory among processes according to their usage patterns.

The underlying technology is called memory mapping (e.g. mmap on Linux). Simplified, it makes data on disk available in RAM and thus serves as an excellent cache. The management is completely up to the OS, which has significant advantages. In short, it automatically uses more memory if available. And it can operate using very little memory. Thus, there is no need to manage or limit the cache. Adding to this is the fact that ObjectBox itself consumes very little resources (CPU & RAM), and thus leaves more RAM for caching compared to traditional databases.

We have seen 100.000 **concurrent** clients connected to a single machine. Depending on the details of your application, a single machine might already be able to serve the need. But of course, you would want to have a cluster anyway for different reasons. Thus, the load can be shared among the cluster nodes for additional scaling.

• ARM starting at v6, mainly v7 for 32 bit and aarch64.
• x86 and x64

There are no limits. Note: Link out Vector Search to the Vector Search docs!

32-bit CPU (e.g. ARM-v6, x86), 16 MB RAM, POSIX OS

Yes, ObjectBox can be run on any POSIX system and in any cloud (e.g. AWS/Azure/Google Cloud/etc). If you are familiar with one of these, it’s usually simple to set up. We prefer to put this in your hands, but sometimes we can support this on an hourly basis. As a first step, we still recommend trying out Sync using a simple setup, e.g. run the server on a developer machine.

ObjectBox syncs between ObjectBox instances. We will eventually support back end DBs with connectors, but for now it needs to be custom built. If you build one, it would be great if you would give it back to the open source community and let us know. If you have more money than time and want us to build one, please reach out via contact[at]objectbox.io.

ObjectBox is an offline-first solution. While we do plan to offer hosting in the future, at the moment the Sync Server can only be self-hosted. You are welcome to use any cloud provider of your choice.

Peer-to-peer sync is not yet possible with ObjectBox; it is on the roadmap only. However, ObjectBox Sync might be helpful in your use case even without p2p, as it tracks all changes when the device is offline and syncs them once back online. In our experience, many use cases don’t actually need p2p synchronisation. Also, consider that the Objectbox Sync Server can be hosted on small devices (like e.g. an ECU, a smartphone, a raspberry pi, a laptop) and is therefore perfect for local setups and on-site synchronisation between devices. Learn more about it here: https://sync.objectbox.io/#online-offline

No. You can use it for full replication, but ObjectBox Data Sync is much more….

ObjectBox really excels in decentralised systems of restricted devices (like e.g. ECUs in cars) and offline scenarios, where efficiency and reliability matter the most. We have a strong foothold in Mobile and IoT projects, e.g. Connected Cars, Smart Manufacturing Apps, and Consumer Apps. The best way to determine if ObjectBox would be a good fit for your application is to set you up with a free trial, so you can try it hands-on. You can apply for one here: https://objectbox.io/sync.

However, you should be aware that we do not yet support user-specific data sync. This means that all data is shared between all devices/users/etc, which is an important requirement for some projects, while for others the opposite is the case.

Learn more about the limitations here: https://objectbox.io/sync#limitations

• For the Data Sync in cluster-mode, there’s global (strong) consistency within the cluster (according to RAFT; e.g. CP of the CAP properties).
• When clients come into play things are not as straight-forward: Clients have their own local storage that is always(!) available even when offline.
• Thus, by definition, they cannot be strongly consistent, but their changes are eventually applied to the cluster (meaning: AP of CAP).
• So, basically the role of a machine / device (client vs. cluster node) also defines their CAP properties; you can choose which is more important to you: availability or consistency.

No, it can run as a plain executable. Further, we also allow embedding client, server and cluster nodes into an application (e.g. linked into the app’s executable, running in the app’s process).

We strongly believe in Open Source. With greenDAO and EventBus we have been contributing to open source for years. Therefore, we open sourced the ObjectBox language bindings under the Apache 2.0 license. We think it is the most interesting part for developers and really allows everyone to use ObjectBox. Generally, we want to open source more components at some point, but first we need to figure out some things. We shared a review of the open source landscape in the infrastructure space here. If you need access to the core, please reach out to us individually. We’re currently putting all our efforts in advancing the product. Please contact us if you have questions about this (contact [at] objectbox.io). Thank you.

Here is an overview of the current licenses for a typical Java/Android project that is hopefully helpful:

Note that the Gradle plugin adds Java and native libraries to your project dependencies as needed.

Maven Central search is a way to see all dependencies and their licenses.

Note that for other languages (e.g. Dart/Flutter) the situation is similar, e.g. the language binding is Apache 2.0 and the native library uses the ObjectBox Binary License.

The current license is temporary only. We will adjust it to be easier and more pragmatic as soon as we can. If you see issues with the current license, please contact us. We’re sure, we can figure it out. We want you to succeed with ObjectBox, and the license should not be an issue.

ObjectBox uses open source software like LMDB and Flatbuffers; find the list of software we love here.

The ObjectBox core database will always be free to use. We are offering additional commercial services and products for and around the core ObjectBox database.

Example for commercial services we offer:

• Data Sync, which takes care of synchronizing data between devices (e.g. several on-premise devices, client-server scenarios). No internet needed, fully cloud-optional.
• Time series extension for fast on-device time series data management.
• Piroritizing feature development: In case you are lacking a feature that’s crucial for you, talk to us.
• Initial Setup and Training: to get you started asap, we can come in and help you integrate ObjectBox.
• Support: If you need professional support agreements, we can help