diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md
deleted file mode 100644
index e39a8b3c..00000000
--- a/.github/ISSUE_TEMPLATE.md
+++ /dev/null
@@ -1,31 +0,0 @@
-*Before creating a new issue, make sure that you checked: (1) existing issues, (2) docs (3) FAQ.
-TEMPLATE FOR ISSUES ONLY - for feature requests just delete the text and start fresh.
-Please help us to fix issues asap: this template reduces checking with you back and forth.
-Replace italic sections with your input.
-For __support questions__, please use [stackoverflow with the [objectbox] tag](https://stackoverflow.com/questions/tagged/objectbox) - we get notified.*
-
-## Issue Basics
-- ObjectBox version (are using the latest version?): *?*
-- Reproducibility: *[occurred once only | occasionally without visible pattern | always]*
-
-## Reproducing the bug
-### Description
-*Describe the situation in English in which you encounter the bug.*
-
-### Code
-*Provide the code triggering the bug.
-Ideally, try to keep it short by removing as much code as possible while preserving the issue.
-You get __extra karma points__ for sharing a runnable project on GitHub that reproduces the bug.*
-
-### Logs & stackstraces
-*Check if you have relevant logs and/or a stacktrace.
-For __build issues__, use `--stacktrace` for the Gradle build (`./gradlew build --stacktrace`).
-For __runtime errors__, check Android's Logcat (check also for relevant logs preceeding the issue itself).*
-
-## Entities
-*Provide the code for entities related to the bug (shorten to relevant parts).*
-
-## Misc
-*Is there anything special about your app?
-May transactions or multi-threading play a role?
-Did you find any workarounds to prevent the issue?*
diff --git a/.github/ISSUE_TEMPLATE/bug_report.md b/.github/ISSUE_TEMPLATE/bug_report.md
new file mode 100644
index 00000000..ebbfb89e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/bug_report.md
@@ -0,0 +1,98 @@
+---
+name: Bug report
+about: You found a bug in ObjectBox causing an application to crash or throw an exception, or something does not work right.
+title: ''
+labels: 'bug'
+assignees: ''
+
+---
+
+<!--
+
+If you are looking for support, please check out our documentation:
+- https://docs.objectbox.io
+- https://docs.objectbox.io/faq
+- https://docs.objectbox.io/troubleshooting
+
+-->
+
+### Is there an existing issue?
+
+- [ ] I have searched [existing issues](https://github.com/objectbox/objectbox-java/issues)
+
+### Build info
+
+- ObjectBox version: [e.g. 3.7.0]
+- OS: [e.g. Android 14 | Ubuntu 22.04 | Windows 11 ]
+- Device/ABI/architecture: [e.g. Galaxy S23 | arm64-v8a | x86-64 ]
+
+### Steps to reproduce
+
+_TODO Tell us exactly how to reproduce the problem._
+
+1. ...
+2. ...
+3. ...
+
+### Expected behavior
+
+_TODO Tell us what you expect to happen._
+
+### Actual behavior
+
+_TODO Tell us what actually happens._
+
+
+### Code
+
+_TODO Add a code example to help us reproduce your problem._
+
+<!--
+
+Please provide a minimal code example.
+
+Things you maybe should also include:
+- the entity class
+- the Gradle build script
+
+You can also create a public GitHub repository and link to it below.
+
+Please do not upload screenshots of text, use code blocks like below instead.
+
+Add any other context about the problem:
+- Is there anything special about your app?
+- May transactions or multi-threading play a role?
+- Did you find any workarounds to prevent the issue?
+
+-->
+
+<details><summary>Code</summary>
+
+```java
+[Paste your code here]
+```
+
+</details>
+
+### Logs, stack traces
+
+_TODO Add relevant logs, a stack trace or crash report._
+
+<!-- 
+
+- For build issues, use `--stacktrace` to run the failing Gradle task. E.g. ./gradlew build --stacktrace
+- For runtime errors, check log output (e.g. Logcat on Android).
+  - For Java/Kotlin exceptions include the full stack trace.
+  - For native crashes on Android, include Logcat output starting from the *** *** *** line. Note that crash reporting tools like Crashlytics may hide this line.
+  - For native crashes on JVM, include the hs_err_pidXXXX.log file.
+  - Also check logs before the error. ObjectBox logs are tagged with e.g. Box.
+
+-->
+
+<details><summary>Logs</summary>
+
+```console
+[Paste your logs here]
+```
+
+</details>
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
new file mode 100644
index 00000000..2aac0df1
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Question
+    url: https://stackoverflow.com/questions/tagged/objectbox
+    about: Ask how to do something, or why it isn't working on Stack Overflow.
diff --git a/.github/ISSUE_TEMPLATE/feature_request.md b/.github/ISSUE_TEMPLATE/feature_request.md
new file mode 100644
index 00000000..1846a02e
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/feature_request.md
@@ -0,0 +1,37 @@
+---
+name: Feature request
+about: Suggest an improvement for ObjectBox.
+title: ''
+labels: 'enhancement'
+assignees: ''
+
+---
+
+<!--
+
+If you are looking for support, please check out our documentation:
+- https://docs.objectbox.io
+- https://docs.objectbox.io/faq
+- https://docs.objectbox.io/troubleshooting
+
+-->
+
+### Is there an existing issue?
+
+- [ ] I have searched [existing issues](https://github.com/objectbox/objectbox-java/issues)
+
+### Use case
+
+_TODO Describe what problem you are trying to solve._
+
+### Proposed solution
+
+_TODO Describe what you want to be able to do with ObjectBox._
+
+### Alternatives
+
+_TODO Describe any alternative solutions or features you've considered._
+
+### Additional context
+
+_TODO Add any other context (e.g. platform or language) about the feature request here._
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 00000000..2c431b0b
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,9 @@
+# Please see the documentation for all configuration options:
+# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
+
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
diff --git a/.github/workflows/close-no-response.yml b/.github/workflows/close-no-response.yml
new file mode 100644
index 00000000..3e906671
--- /dev/null
+++ b/.github/workflows/close-no-response.yml
@@ -0,0 +1,26 @@
+name: Close inactive issues
+on:
+  schedule:
+    - cron: "15 1 * * *" # “At 01:15.”
+  workflow_dispatch: # To support running manually.
+
+# Minimal access by default
+permissions:
+  contents: read
+
+jobs:
+  close-issues:
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: write
+    steps:
+      # https://github.com/marketplace/actions/close-stale-issues
+      - uses: actions/stale@eb5cf3af3ac0a1aa4c9c45633dd1ae542a27a899 # v10.3.0
+        with:
+          days-before-stale: -1 # Add the stale label manually.
+          days-before-close: 21
+          only-labels: "more info required"
+          stale-issue-label: "more info required"
+          close-issue-message: "Without additional information, we are unfortunately not sure how to resolve this issue. Therefore this issue has been automatically closed. Feel free to comment with additional details and we can re-open this issue."
+          close-pr-message: "Without additional information, we are unfortunately not sure how to address this pull request. Therefore this pull request has been automatically closed. Feel free to comment with additional details or submit a new pull request."
diff --git a/.gitignore b/.gitignore
index 5f02f8d1..1bedca93 100644
--- a/.gitignore
+++ b/.gitignore
@@ -12,7 +12,9 @@ gen/
 target/
 out/
 classes/
-gradle.properties
+
+# Kotlin
+.kotlin
 
 # Local build properties
 build.properties
diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml
new file mode 100644
index 00000000..63a5ea1d
--- /dev/null
+++ b/.gitlab-ci.yml
@@ -0,0 +1,238 @@
+# https://docs.gitlab.com/ci/yaml/
+
+# Assumes these environment variables are configured in GitLab CI/CD Settings:
+# - OBX_READ_PACKAGES_TOKEN
+# - SONATYPE_USER
+# - SONATYPE_PWD
+# - GOOGLE_CHAT_WEBHOOK_JAVA_CI
+# Additionally, these environment variables used by the objectbox-publish Gradle script:
+# - ORG_GRADLE_PROJECT_signingKeyFile
+# - ORG_GRADLE_PROJECT_signingKeyId
+# - ORG_GRADLE_PROJECT_signingPassword
+
+variables:
+  OBX_PUBLISH_RELEASE:
+    value: "false"
+    options: [ "false", "true" ]
+    description: "If enabled, builds and depends on release versions and triggers publishing a
+                  release of the Java library artifacts to the internal GitLab repository and Maven Central.
+                  Don't run multiple times to avoid duplicate artifacts in the GitLab repository.
+                  Consult the release checklist before turning this on."
+  # If enabled, builds and depends on release versions. Doesn't publish a release.
+  # See the root Gradle build script for details.
+  OBX_RELEASE: "false"
+
+  # Disable the Gradle daemon. Gradle may run in a Docker container with a shared
+  # Docker volume containing GRADLE_USER_HOME. If the container is stopped after a job
+  # Gradle daemons may get killed, preventing proper clean-up of lock files in GRADLE_USER_HOME.
+  # Use low priority processes to avoid Gradle builds consuming all build machine resources.
+  GRADLE_OPTS: "-Dorg.gradle.daemon=false -Dorg.gradle.priority=low"
+  GITLAB_REPO_ARGS: "-PgitlabUrl=$CI_SERVER_URL -PgitlabPrivateTokenName=Deploy-Token -PgitlabPrivateToken=$OBX_READ_PACKAGES_TOKEN"
+  GITLAB_PUBLISH_ARGS: "-PgitlabPublishTokenName=Job-Token -PgitlabPublishToken=$CI_JOB_TOKEN"
+  CENTRAL_PUBLISH_ARGS: "-PsonatypeUsername=$SONATYPE_USER -PsonatypePassword=$SONATYPE_PWD"
+  # CI_COMMIT_REF_SLUG is the branch or tag name, but web-safe (only 0-9, a-z)
+  VERSION_ARGS: "-PversionSuffix=$CI_COMMIT_REF_SLUG"
+
+# Using multiple test stages to avoid running some things in parallel (see job notes).
+stages:
+  - test
+  - publish-maven-internal
+  - publish-maven-central
+  - package-api-docs
+  - triggers
+
+workflow:
+  rules:
+    # Disable merge request pipelines https://docs.gitlab.com/ci/jobs/job_rules/#ci_pipeline_source-predefined-variable
+    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+      when: never
+    # On main branch, always use release versions as old snapshots of dependencies are deleted
+    - if: $CI_COMMIT_REF_NAME == "main"
+      variables:
+        OBX_RELEASE: "true"
+    # To publish a release must use release versions
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      variables:
+        OBX_RELEASE: "true"
+    # In all other cases, create a pipeline
+    - when: always
+
+.docker_linux_x64_android: &docker_linux_x64_android
+  tags:
+    - docker
+    - linux
+    - x64
+  image: objectboxio/buildenv-android:2026-05-12 # With JDK 21, Android build-tools;35.0.0 and platforms;android-35 pre-installed
+  variables:
+    # Image defaults to POSIX (ASCII), set a compatible locale so UTF-8 tests that interact with the file system work.
+    # Check with 'locale -a' for available locales.
+    LC_ALL: "C.UTF-8"
+
+.test_base:
+  before_script:
+    # Print Gradle and JVM version info
+    - ./gradlew -version
+    # Remove any previous JVM (Hotspot) crash log.
+    # "|| true" for an OK exit code if no file is found
+    - rm **/hs_err_pid*.log || true
+  # By default, don't compile and test the Android APIs (only do in test job), there is currently no benefit to test
+  # them using multiple platforms or JDKs.
+  script: ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build -PexcludeAndroid=true
+  artifacts:
+    when: always
+    paths:
+      - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash
+    reports:
+      junit: "**/build/test-results/**/TEST-*.xml"
+
+test:
+  <<: *docker_linux_x64_android
+  extends: .test_base
+  stage: test
+  # Overwrite script key to run through ASAN script, compile and test Android APIs and test build of Web API docs.
+  # Note: Address sanitizer is only available on Linux runners (see script).
+  script:
+    # build to assemble, run tests and spotbugs
+    # javadocForWeb to catch API docs errors before releasing
+    # Temporarily disable testing with Address Sanitizer until buildenv images are modernized, see #273
+    # - ./scripts/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean build javadocForWeb
+    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean build javadocForWeb
+  # Overwrite artifacts key to archive spotbugs reports
+  artifacts:
+    when: always
+    paths:
+      - "**/hs_err_pid*.log" # Only on JVM (Hotspot) crash.
+      - "**/build/reports/spotbugs/*.html"
+    reports:
+      junit: "**/build/test-results/**/TEST-*.xml"
+
+.test_jdks:
+  <<: *docker_linux_x64_android
+  extends: .test_base
+  # Overwrite script key to run through ASAN script and to run test task directly to avoid
+  # running SpotBugs (build runs check runs SpotBugs tasks).
+  # Note: Address sanitizer is only available on Linux runners (see script).
+  script:
+    # Temporarily disable testing with Address Sanitizer until buildenv images are modernized, see #273
+    # - ./scripts/test-with-asan.sh $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
+    - ./gradlew $GITLAB_REPO_ARGS $VERSION_ARGS clean :tests:objectbox-java-test:test
+
+# Test oldest supported and a recent JDK.
+test-jdk-8:
+  extends: .test_jdks
+  needs: ["test"]
+  variables:
+    TEST_JDK: 8
+
+# JDK 21 is the default of the current build image, so test the latest LTS JDK 25
+test-jdk-25:
+  extends: .test_jdks
+  needs: ["test"]
+  variables:
+    TEST_JDK: 25
+
+test-macos:
+  extends: .test_base
+  tags:
+    - jdk
+    - mac
+
+test-windows:
+  extends: .test_base
+  tags:
+    - jdk
+    - windows
+    - x64
+
+test-windows-jdk-x86:
+  extends: .test_base
+  tags:
+    - jdk-x86
+    - windows
+  variables:
+    # TEST_WITH_JAVA_X86 makes objectbox-java-test use 32-bit java executable and therefore
+    # 32-bit ObjectBox to run tests (see build.gradle file).
+    # Note: assumes JAVA_HOME_X86 is set to 32-bit JDK path.
+    TEST_WITH_JAVA_X86: "true"
+
+# Publish Maven artifacts to internal Maven repo
+publish-maven-internal:
+  <<: *docker_linux_x64_android
+  stage: publish-maven-internal
+  rules:
+    # Not for tag pipelines (Maven artifact snapshots are versioned using the branch name)
+    - if: $CI_COMMIT_TAG
+      when: never
+    # Not when using release versions and not publishing a release to avoid duplicate artifacts
+    # (GitLab would allow to upload duplicates for a release version)
+    - if: $OBX_RELEASE == "true" && $OBX_PUBLISH_RELEASE != "true"
+      when: never
+    # Not if triggered by upstream project to save on disk space
+    - if: $CI_PIPELINE_SOURCE == "pipeline"
+      when: never
+    # Not for scheduled pipelines to save on disk space
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      when: never
+    # Otherwise, only if no previous stages failed
+    - when: on_success
+  script:
+    - ./gradlew $GITLAB_REPO_ARGS $GITLAB_PUBLISH_ARGS $VERSION_ARGS publishAllPublicationsToGitLabRepository
+
+# Publish Maven artifacts to public Maven Central repo
+publish-maven-central:
+  <<: *docker_linux_x64_android
+  stage: publish-maven-central
+  rules:
+    # Only if publishing a release, only if no previous stages failed
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      when: on_success
+  before_script:
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java libraries (job = $CI_JOB_NAME, ref = $CI_COMMIT_REF_NAME, commit = $CI_COMMIT_SHORT_SHA) ..."
+  script:
+    # Note: supply internal repo as tests use native dependencies that might not be available publicly, yet.
+    - ./gradlew $GITLAB_REPO_ARGS $CENTRAL_PUBLISH_ARGS publishAllPublicationsToSonatypeRepository closeAndReleaseSonatypeStagingRepository
+  after_script:
+    # Also runs on failure, so print CI_JOB_STATUS
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "*Releasing Java libraries (job = $CI_JOB_NAME, ref = $CI_COMMIT_REF_NAME, commit = $CI_COMMIT_SHORT_SHA) job status = *$CI_JOB_STATUS*"
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "Check https://repo1.maven.org/maven2/io/objectbox/ in a few minutes."
+
+# Create Java API docs archive
+package-api-docs:
+  <<: *docker_linux_x64_android
+  stage: package-api-docs
+  rules:
+    # Only if publishing a release, only if no previous stages failed
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      when: on_success
+  script:
+    - ./gradlew $GITLAB_REPO_ARGS :objectbox-java:packageJavadocForWeb
+  after_script:
+    - ci/send-to-gchat.sh "$GOOGLE_CHAT_WEBHOOK_JAVA_CI" --thread $CI_COMMIT_SHA "API docs for web available as job artifact $CI_JOB_URL"
+  artifacts:
+    paths:
+      - "objectbox-java/build/dist/objectbox-java-web-api-docs.zip"
+
+# Trigger Gradle plugin build to test new Maven snapshots of this project
+trigger-plugin:
+  stage: triggers
+  rules:
+    # Not for tag pipelines
+    - if: $CI_COMMIT_TAG
+    - when: never
+    # Not when publishing a release
+    - if: $OBX_PUBLISH_RELEASE == "true"
+      when: never
+    # Do not trigger publishing of plugin
+    - if: $CI_COMMIT_BRANCH == "publish"
+      when: never
+    # Not for scheduled pipelines where Maven snapshots of this project do not change
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      when: never
+    # Otherwise, only if no previous stages failed. Also set allow_failure in case branch does not exist downstream.
+    - when: on_success
+  inherit:
+    variables: false
+  allow_failure: true # Branch might not exist in plugin project
+  trigger:
+    project: objectbox/objectbox-plugin
+    branch: $CI_COMMIT_BRANCH
diff --git a/.gitlab/merge_request_templates/Default.md b/.gitlab/merge_request_templates/Default.md
new file mode 100644
index 00000000..100c5fd0
--- /dev/null
+++ b/.gitlab/merge_request_templates/Default.md
@@ -0,0 +1,28 @@
+## What does this merge request do?
+
+TODO Link associated issue from title, like: `<title> #NUMBER`
+
+TODO Briefly list what this merge request is about
+
+## Author's checklist
+
+- [ ] This merge request fully addresses the requirements of the associated task
+- [ ] I did a self-review of the changes and did not spot any issues, among others:
+  - I added unit tests for new or changed behavior; existing and new tests pass
+  - I checked the SpotBugs report for new issues
+  - My code conforms to our coding standards and guidelines
+  - My changes are prepared (focused commits, good messages) so reviewing them is easy for the reviewer
+- [ ] I amended the [changelog](/CHANGELOG.md) if this affects users in any way
+- [ ] I assigned a reviewer to request review
+
+## Reviewer's checklist
+
+- [ ] I reviewed all changes line-by-line and addressed relevant issues. However:
+  - for quickly resolved issues, I considered creating a fixup commit and discussing that, and
+  - instead of many or long comments, I considered a meeting with or a draft commit for the author.
+- [ ] The requirements of the associated task are fully met
+- [ ] I can confirm that:
+  - CI passes
+  - If applicable, coverage percentages do not decrease
+  - New code conforms to standards and guidelines
+  - If applicable, additional checks were done for special code changes (e.g. core performance, binary size, OSS licenses)
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 00000000..ece02fa5
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,42 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+- Multi-module Gradle build. Core modules live at the repo root: `objectbox-java-api`, `objectbox-java`, `objectbox-kotlin`, `objectbox-rxjava`, `objectbox-rxjava3`, and `objectbox-android`.
+- `objectbox-android` requires the Android SDK; exclude it with `-PexcludeAndroid=true` if the SDK is unavailable.
+- Test modules live under `tests/`, notably `tests/objectbox-java-test` and `tests/test-proguard`.
+- Shared build logic (e.g., publishing conventions) lives in the `build-logic/` included build.
+- Source follows standard Gradle layout per module (e.g., `src/main/java`, `src/main/kotlin`, `src/test/java`).
+- CI config: `.gitlab-ci.yml` (primary; Jenkins is obsolete); helper scripts live in `scripts/`; build outputs go to `build/`.
+
+## Build, Test, and Development Commands
+- `./gradlew clean build` — full build across modules.
+- `./gradlew :objectbox-java:build` — build a single module.
+- `./gradlew :tests:objectbox-java-test:test` — run the main test suite.
+- `./gradlew :tests:objectbox-java-test:test --tests io.objectbox.query.QueryTest` — run a single test class.
+- `./gradlew -version` — verify Gradle/JDK setup.
+- `./scripts/test-with-asan.sh --stacktrace clean build` — CI-style run with ASAN (requires native deps; currently disabled in CI, see issue #273).
+
+## Coding Style & Naming Conventions
+- No repo-wide formatter config is present; follow existing Java/Kotlin style in the touched files and keep changes minimal.
+- Use 4-space indentation and standard Java/Kotlin naming conventions; prefer package naming under `io.objectbox`.
+- New tests in `tests/objectbox-java-test` should name methods as `{attribute}_{queryCondition}_{expectation}` (see `tests/README.md`).
+
+## Testing Guidelines
+- Tests are JUnit-based (see `tests/objectbox-java-test/build.gradle.kts`).
+- Tests run against the real native database library (`io.objectbox:objectbox-linux`/`-macos`/`-windows` from Maven).
+  Snapshot versions of these resolve only via the internal GitLab repository (`gitlabUrl`/`gitlabPrivateToken` Gradle properties, see `settings.gradle.kts`).
+- Place new tests under `tests/objectbox-java-test/src/test/java` (or Kotlin equivalents).
+- Legacy tests may still use the `test*` prefix; new tests should follow the naming convention above.
+
+## Key Classes & Hotspots
+- Core API: `io.objectbox.BoxStore`, `io.objectbox.Box`, and `io.objectbox.Transaction` (see `tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java` and `tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java`).
+- Queries: `io.objectbox.query.Query`, `QueryBuilder`, and `QueryCondition` (see `tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java` and `tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java`).
+- Relations: `io.objectbox.relation.ToOne` and `ToMany` (see `tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java`).
+- Sync: `io.objectbox.sync.SyncClient`, `SyncServer`, and `SyncCredentials` (see `tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java`).
+
+## Commit & Pull Request Guidelines
+- The default branch for development and PRs is `dev`; the `publish` branch is used for releases to Maven Central.
+- Recent history uses a short area prefix, e.g., `QueryTest: use new API...` or `TargetIdProperty: improve...`. Follow this pattern for new commits.
+- Add user-facing changes to the "Next release" section of `CHANGELOG.md`.
+- PRs should include a concise summary, rationale, and the exact test commands run.
+- If changes affect native or CI behavior, call that out explicitly (CI tests against the oldest supported JDK 8 and a recent JDK, see `.gitlab-ci.yml`).
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 00000000..3d89fa82
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,318 @@
+# Changelog
+
+Notable changes to the ObjectBox Java library.
+
+For more insights into what changed in the database libraries, [check the ObjectBox C changelog](https://github.com/objectbox/objectbox-c/blob/main/CHANGELOG.md).
+
+## 6.0.0-beta - 2026-07-14
+
+* Update Android and JVM libraries to database version `6.0.0-beta-2026-07-13`
+  * Admin: modernized user interface based on Vue.js 3 and Material Design 3
+  * Admin: optimized pages now loading faster
+  * Android: log messages now use the logcat tag "ObjectBox" (previously "Box")
+  * Internal fixes and improvements
+* objectbox-kotlin: requires at least Kotlin compiler and standard library 2.2.0
+
+### Sync
+
+* **New** [Mesh Sync API](https://sync.objectbox.io/mesh-sync): peer-to-peer (P2P) synchronization between sync clients without a central server.  
+  * Attach a `MeshConfig` via `SyncBuilder.mesh()` and query the running mesh via `SyncClient.getMesh()` (state, connected peer count, statistics counters). 
+    Mesh configurations are created by ObjectBox platform libraries that provide a mesh network (transport).
+  * New artifact `objectbox-meshsync-android`: provides the mesh network for Android using Google Nearby Connections. Add it next to the Sync variant of the Android library (like `objectbox-sync-android`) and create a mesh configuration with `AndroidMeshSync.createConfig(context, meshId)`. It includes the permissions required by Nearby Connections and the `play-services-nearby` dependency. See [its README for details](objectbox-meshsync-android/README.md).
+
+## 5.4.2 - 2026-05-05
+
+- Update Android and JVM libraries to database version `5.3.2-2026-05-05`
+  - Fixed a corner case with "unique replace on conflict" and absent (e.g. null) sync clock value
+  - Internal fixes and improvements
+
+## 5.4.1 - 2026-03-26
+
+- Update Android and JVM libraries to database version `5.3.1-2026-03-26`
+
+### Sync
+
+- Critical fix for sync clock property handling
+
+## 5.4.0 - 2026-03-24
+
+- Update Android and JVM libraries to database version `5.3.0-2026-03-23`
+- Admin: Status tab "Count and Sizes" and "System and Info" improved
+
+### Sync
+
+- Conflict resolution via the new annotations `@SyncClock` and `@SyncPrecedence` (allows last win with custom conflict
+  resolution)
+- Fix bad Sync client state after multiple full sync messages were interrupted
+- Fix adding indexes to Sync types
+
+## 5.3.0 - 2026-03-10
+
+- Gradle plugin: to apply the plugin, it is no longer necessary to add a manual mapping of the plugin ID in your
+  projects Gradle settings file. This was resolved by publishing Gradle plugin marker artifacts.
+  [#960](https://github.com/objectbox/objectbox-java/issues/960)
+- Gradle plugin: it is no longer necessary to apply the plugin after the dependencies block when manually including
+  ObjectBox dependencies.
+- Update database libraries for Android and JVM to database version `5.2.0-next-2026-03-10`
+- (Minor) performance improvements of HNSW vector search on Linux ARM targets
+                    
+### Sync
+
+- Sync protocol version 10
+- SyncClient: support updating filter variables. After login, stage updates using put and remove, then schedule to send
+  them to the server with `applyFilterVariables()`.
+- Update client sync filters variables when online
+- Clients report errors to the server
+
+### Migration instructions
+
+#### Drop the Gradle plugin ID mapping
+
+If your `settings.gradle.kts` or `settings.gradle` file contains lines similar to:
+
+```kotlin
+pluginManagement {
+    repositories {
+        mavenCentral()
+    }
+    
+    resolutionStrategy {
+        eachPlugin {
+            if (requested.id.id == "io.objectbox") {
+                useModule("io.objectbox:objectbox-gradle-plugin:${requested.version}")
+            }
+        }
+    }
+}
+```
+
+Update them to remove the plugin mapping configuration:
+
+```kotlin
+pluginManagement {
+    repositories {
+        mavenCentral()
+    }
+}
+```
+
+#### Apply the plugin using plugins syntax
+
+If your build scripts are applying the plugin after the dependencies block similar to:
+
+```kotlin
+dependencies {
+    // ...  
+} 
+
+apply(plugin = "io.objectbox")
+```
+
+Change them to apply the plugin using plugins syntax:
+
+```kotlin
+plugins {
+    id("io.objectbox")
+}
+
+dependencies {
+    // ...  
+}
+```
+
+## 5.2.0 - 2026-02-16
+
+- The [ObjectBox Gradle plugin](https://github.com/objectbox/objectbox-java-generator) requires JDK 11 and Android
+  Gradle Plugin 8.1 or newer.
+- Update database libraries for Android and JVM to database version `5.1.1-pre-2026-02-16`.
+- Admin: new "Counts and Sizes" view (via Status page) to give an overview over all types their object counts and sizes
+- Admin: fix reload via browser to stay on the page
+- Admin: schema view to display flags as text
+- Admin: refresh button for the data view
+
+### Sync
+
+- Add simplified `Sync.client(boxStore)` helper method. Move URL and credentials options to builder, add variants that 
+  accept multiple URLs and credentials. Deprecate the existing helper methods.
+- Add Sync client builder option to configure Sync behavior using 
+  [SyncFlags](objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java).
+
+## 5.1.0 - 2026-01-26
+
+- Add [ObjectBoxThreadPoolExecutor](objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java), a
+  default implementation of a `ThreadPoolExecutor` that properly cleans up thread-local Box resources.
+- Add methods `newCachedThreadPoolExecutor()` and `newFixedThreadPoolExecutor()` to `BoxStore` to help create instances
+  of `ObjectBoxThreadPoolExecutor` for common uses.
+- Add methods `newCachedThreadPoolDispatcher()` and `newFixedThreadPoolDispatcher()` to the Kotlin extension functions
+  for `BoxStore` to help create common coroutine dispatchers backed by an `ObjectBoxThreadPoolExecutor`.
+- `BoxStore.runInTx` and `callInTx` close a write cursor even if the runnable or callable throws. This would previously
+  result in cursor not closed warnings when the cursor was closed by the finalizer daemon. 
+- `BoxStore` no longer gets stuck while closing when deleting transactions created in other threads with open relation
+  cursors.
+- Admin: the Schema view now shows if external name of types and properties if configured.
+- Admin: the Schema view now shows the type as text (e.g. "String") instead of the internal type ID.
+                          
+### Sync
+
+- New Sync protocol V8: using new clients also requires a server update
+- Remove superfluous sync listener triggers when sync filters "report updates" (SKIP_TX)
+- Sync clients compress earlier: reduces disk storage for outgoing data
+- Reworked certificates for Apple platforms
+- Removed support for older Sync protocol versions before 2024-09; protocol V5+ is now required.
+
+## 5.0.1 - 2025-09-30
+
+- Update runtime libraries for Android and JVM to database version `5.0.0-2025-09-27`.
+- Fix a race condition with a closing store and still active transactions that kept the store from closing.
+  For Android this may fix some rare ANR issues.
+
+### Sync
+
+- Add `filterVariables` option to `SyncClient` builder for [Sync filters](https://sync.objectbox.io/sync-server/sync-filters)
+  introduced in version 5.0.
+
+## 5.0.0 - 2025-09-17
+
+- Includes runtime libraries for Android and JVM with database version `5.0.0-2025-09-16`.
+  - Android: Prior to Android 8.0, don't crash when inserting objects with string lists whose size exceeds the local
+    reference table size. [#1215](https://github.com/objectbox/objectbox-java/issues/1215) 
+  - ToOne relations: when deleting an object with an ID larger than the maximum 32-bit unsigned integer 
+    (`4_294_967_295`) that is used as the target object of a ToOne, correctly re-set the target ID of the ToOne to
+    `0`. [objectbox-dart#740](https://github.com/objectbox/objectbox-dart/issues/740) 
+- When re-creating a `BoxStore` for the same directory and `close()` wasn't called on the previous instance, don't throw
+  an "Another BoxStore is still open for this directory" exception. Note that calling `close()` *is recommended* before 
+  creating a new instance. [#1201](https://github.com/objectbox/objectbox-java/issues/1201)
+- When using `BoxStoreBuilder.buildDefault()`, don't leak the Store when setting it as default fails.
+- To help diagnose, print stacks of all threads in the internal thread pool if shutting it down takes too long when
+  closing `BoxStore`.
+- Remove deprecated APIs:
+  - `Query.setParameters` methods that set a single parameter, use the `setParameter` methods instead.
+  - `Box.removeByKeys`, use `Box.removeByIds` instead.
+  - `BoxStore.sizeOnDisk`, use `getDbSize` or `getDbSizeOnDisk` instead which properly handle in-memory databases.
+  - `BoxStoreBuilder.debugTransactions`, use `debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE)` instead.
+  - `SyncServerBuilder` `peer` configuration options, use the `clusterPeer` options instead.
+  - `io.objectbox.DebugFlags`, use `io.objectbox.config.DebugFlags` instead.
+  - `ValidateOnOpenMode` constants, use `ValidateOnOpenModePages` instead.
+  - DAOcompat compatibility query methods. Use the regular query API instead.           
+
+### Sync
+
+- Support Sync server version 5.0.
+  - **User-Specific Data Sync**: support configuring [Sync filter](https://sync.objectbox.io/sync-server/sync-filters) 
+    variables on `SyncClient`.
+
+## 4.3.1 - 2025-08-12
+
+- Requires at least Kotlin compiler and standard library 1.7.
+- Data Observers: closing a Query now waits on a running publisher to finish its query, preventing a VM crash. [#1147](https://github.com/objectbox/objectbox-java/issues/1147)
+- Update database libraries for Android and JVM to version `4.3.1` (include database version `4.3.1-2025-08-02`).
+
+## 4.3.0 - 2025-05-13
+
+- Basic support for boolean array properties (`boolean[]` in Java or `BooleanArray` in Kotlin).
+- The Windows database library now statically links the MSVC runtime to avoid crashes in incompatible `msvcp140.dll` 
+  shipped with some JDKs.
+- External property types (via [MongoDB connector](https://sync.objectbox.io/mongodb-sync-connector)):
+  - add `JSON_TO_NATIVE` to support sub (embedded/nested) documents/arrays in MongoDB
+  - support ID mapping to UUIDs (v4 and v7)
+- Admin: add class and dependency diagrams to the schema page (view and download).
+- Admin: improved data view for large vectors by displaying only the first elements and the full vector in a dialog.
+- Admin: detects images stored as bytes and shows them as such (PNG, GIF, JPEG, SVG, WEBP).
+
+### Sync
+
+- Add "Log Events" for important server events, which can be viewed on a new Admin page.
+- Detect and ignore changes for objects that were put but were unchanged.
+- The limit for message size was raised to 32 MB.
+- Transactions above the message size limit now already fail on the client (to better enforce the limit).
+
+## 4.2.0 - 2025-03-04
+
+- Add new query conditions `equalKeyValue`, `greaterKeyValue`, `lessKeyValue`, `lessOrEqualKeyValue`, and 
+  `greaterOrEqualKeyValue` that are helpful to write complex queries for [string maps](https://docs.objectbox.io/advanced/custom-types#flex-properties).
+  These methods support `String`, `long` and `double` data types for the values in the string map.
+- Deprecate the `containsKeyValue` condition, use the new `equalKeyValue` condition instead.
+- Android: to build, at least Android Plugin 8.1.1 and Gradle 8.2.1 are required.
+
+## 4.1.0 - 2025-01-30
+
+- Vector Search: add new `VectorDistanceType.GEO` distance type to perform vector searches on geographical coordinates.
+  This is particularly useful for location-based applications.
+- Android: require Android 5.0 (API level 21) or higher.
+- Note on Windows JVM: We've seen crashes on Windows when creating a BoxStore on some JVM versions.
+  If this should happen to you, make sure to update your JVM to the latest patch release
+  (8.0.432+6, 11.0.25+9, 17.0.13+11 and 21.0.5+11-LTS are known to work).
+
+### Sync
+
+- Add JWT authentication
+- Sync clients can now send multiple credentials for login
+
+## 4.0.3 - 2024-10-15
+
+- Make closing the Store more robust. In addition to transactions, it also waits for ongoing queries. This is just an
+  additional safety net. Your apps should still make sure to finish all Store operations, like queries, before closing it.
+- [Flex properties](https://docs.objectbox.io/advanced/custom-types#flex-properties) support `null` map and list values.
+- Some minor vector search performance improvements.
+
+### Sync
+
+- **Fix a serious regression, please update as soon as possible.**
+- Add new options, notably for cluster configuration, when building `SyncServer`. Improve documentation.
+  Deprecate the old peer options in favor of the new cluster options.
+- Add `SyncHybrid`, a combination of a Sync client and a Sync server. It can be used in local cluster setups, in
+  which a "hybrid" functions as a client & cluster peer (server).
+
+## 4.0.2 - 2024-08-20
+
+- Add convenience `oneOf` and `notOneOf` conditions that accept `Date` to avoid manual conversion using `getTime()`.
+- When `BoxStore` is closing, briefly wait on active transactions to finish.
+- Guard against crashes when `BoxStore` was closed, but database operations do still occur concurrently (transactions are still active).
+
+## 4.0.1 - 2024-06-03
+
+- Examples: added [Vector Search example](https://github.com/objectbox/objectbox-examples/tree/main/java-main-vector-search) that demonstrates how to perform on-device [approximate nearest neighbor (ANN) search](https://docs.objectbox.io/on-device-vector-search).
+- Revert deprecation of `Box.query()`, it is still useful for queries without any condition.
+- Add note on old query API methods of `QueryBuilder` that they are not recommended for new projects. Use [the new query APIs](https://docs.objectbox.io/queries) instead.
+- Update and expand documentation on `ToOne` and `ToMany`.
+
+## 4.0.0 - Vector Search - 2024-05-16
+
+**ObjectBox now supports** [**Vector Search**](https://docs.objectbox.io/ann-vector-search) to enable efficient similarity searches.
+
+This is particularly useful for AI/ML/RAG applications, e.g. image, audio, or text similarity. Other use cases include semantic search or recommendation engines.
+
+Create a Vector (HNSW) index for a floating point vector property. For example, a `City` with a location vector:
+
+```java
+@Entity
+public class City {
+
+    @HnswIndex(dimensions = 2)
+    float[] location;
+    
+}
+```
+
+Perform a nearest neighbor search using the new `nearestNeighbors(queryVector, maxResultCount)` query condition and the new "find with scores" query methods (the score is the distance to the query vector). For example, find the 2 closest cities:
+
+```java
+final float[] madrid = {40.416775F, -3.703790F};
+final Query<City> query = box
+        .query(City_.location.nearestNeighbors(madrid, 2))
+        .build();
+final City closest = query.findWithScores().get(0).get();
+```
+
+For an introduction to Vector Search, more details and other supported languages see the [Vector Search documentation](https://docs.objectbox.io/ann-vector-search).
+
+- BoxStore: deprecated `BoxStore.sizeOnDisk()`. Instead use one of the new APIs to determine the size of a database:
+  - `BoxStore.getDbSize()` which for a file-based database returns the file size and for an in-memory database returns the approximately used memory,
+  - `BoxStore.getDbSizeOnDisk()` which only returns a non-zero size for a file-based database.
+- Query: add properly named `setParameter(prop, value)` methods that only accept a single parameter value, deprecated the old `setParameters(prop, value)` variants.
+- Sync: add `SyncCredentials.userAndPassword(user, password)`.
+- Gradle plugin: the license of the [Gradle plugin](https://github.com/objectbox/objectbox-java-generator) has changed to the GNU Affero General Public License (AGPL).
+
+## Previous versions
+
+See the [Changelogs in the documentation](https://docs.objectbox.io/changelogs).
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 00000000..5cbfa334
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+See @AGENTS.md for repository guidelines
diff --git a/Jenkinsfile b/Jenkinsfile
index a7b8499b..0b821e72 100644
--- a/Jenkinsfile
+++ b/Jenkinsfile
@@ -1,10 +1,21 @@
-// dev branch only: every 30 minutes at night (1:00 - 5:00)
-String cronSchedule = BRANCH_NAME == 'dev' ? '*/30 1-5 * * *' : ''
+// dev branch only: run every hour at 30th minute at night (1:00 - 5:00)
+// Avoid running at the same time as integration tests: uses this projects snapshots
+// so make sure to not run in the middle of uploading a new snapshot to avoid dependency resolution errors.
+String cronSchedule = BRANCH_NAME == 'dev' ? '30 1-5 * * *' : ''
 String buildsToKeep = '500'
 
-String gradleArgs = '-Dorg.gradle.daemon=false --stacktrace'
+String gradleArgs = '--stacktrace'
 boolean isPublish = BRANCH_NAME == 'publish'
-String versionPostfix = isPublish ? '' : BRANCH_NAME // Build script detects empty string as not set.
+String versionSuffix = isPublish ? '' : BRANCH_NAME // Build script detects empty string as not set.
+
+// Note: using single quotes to avoid Groovy String interpolation leaking secrets.
+def signingArgs = '-PsigningKeyFile=$SIGNING_FILE -PsigningKeyId=$SIGNING_ID -PsigningPassword=$SIGNING_PWD'
+def gitlabRepoArgs = '-PgitlabUrl=$GITLAB_URL -PgitlabPrivateToken=$GITLAB_TOKEN'
+def uploadRepoArgsCentral = '-PsonatypeUsername=$OSSRH_LOGIN_USR -PsonatypePassword=$OSSRH_LOGIN_PSW'
+
+boolean startedByTimer = currentBuild.getBuildCauses('hudson.triggers.TimerTrigger$TimerTriggerCause').size() > 0
+def buildCauses = currentBuild.getBuildCauses()
+echo "startedByTimer=$startedByTimer, build causes: $buildCauses"
 
 // https://jenkins.io/doc/book/pipeline/syntax/
 pipeline {
@@ -12,26 +23,19 @@ pipeline {
     
     environment {
         GITLAB_URL = credentials('gitlab_url')
-        MVN_REPO_LOGIN = credentials('objectbox_internal_mvn_user')
-        MVN_REPO_URL = credentials('objectbox_internal_mvn_repo_http')
-        MVN_REPO_ARGS = "-PinternalObjectBoxRepo=$MVN_REPO_URL " +
-                        "-PinternalObjectBoxRepoUser=$MVN_REPO_LOGIN_USR " +
-                        "-PinternalObjectBoxRepoPassword=$MVN_REPO_LOGIN_PSW"
-        MVN_REPO_UPLOAD_URL = credentials('objectbox_internal_mvn_repo')
-        MVN_REPO_UPLOAD_ARGS = "-PpreferredRepo=$MVN_REPO_UPLOAD_URL " +
-                        "-PpreferredUsername=$MVN_REPO_LOGIN_USR " +
-                        "-PpreferredPassword=$MVN_REPO_LOGIN_PSW " +
-                        "-PversionPostFix=$versionPostfix"
+        GITLAB_TOKEN = credentials('GITLAB_TOKEN_ALL')
+        GITLAB_INTEG_TESTS_TRIGGER_URL = credentials('gitlab-trigger-java-integ-tests')
         // Note: for key use Jenkins secret file with PGP key as text in ASCII-armored format.
-        ORG_GRADLE_PROJECT_signingKeyFile = credentials('objectbox_signing_key')
-        ORG_GRADLE_PROJECT_signingKeyId = credentials('objectbox_signing_key_id')
-        ORG_GRADLE_PROJECT_signingPassword = credentials('objectbox_signing_key_password')
+        SIGNING_FILE = credentials('objectbox_signing_key')
+        SIGNING_ID = credentials('objectbox_signing_key_id')
+        SIGNING_PWD = credentials('objectbox_signing_key_password')
     }
 
     options {
         buildDiscarder(logRotator(numToKeepStr: buildsToKeep, artifactNumToKeepStr: buildsToKeep))
         timeout(time: 1, unit: 'HOURS') // If build hangs (regular build should be much quicker)
-        gitLabConnection("${env.GITLAB_URL}")
+        disableConcurrentBuilds() // limit to 1 job per branch
+        gitLabConnection('objectbox-gitlab-connection')
     }
 
     triggers {
@@ -43,8 +47,6 @@ pipeline {
     stages {
         stage('init') {
             steps {
-                sh 'chmod +x gradlew'
-                sh 'chmod +x ci/test-with-asan.sh'
                 sh './gradlew -version'
 
                 // "|| true" for an OK exit code if no file is found
@@ -54,39 +56,75 @@ pipeline {
 
         stage('build-java') {
             steps {
-                sh "./ci/test-with-asan.sh $gradleArgs $MVN_REPO_ARGS -Dextensive-tests=true clean test " +
-                        "--tests io.objectbox.FunctionalTestSuite " +
-                        "--tests io.objectbox.test.proguard.ObfuscatedEntityTest " +
-                        "--tests io.objectbox.rx.QueryObserverTest " +
-                        "--tests io.objectbox.rx3.QueryObserverTest " +
-                        "spotbugsMain assemble"
+                sh "./scripts/test-with-asan.sh $gradleArgs $signingArgs $gitlabRepoArgs clean build"
+            }
+            post {
+                always {
+                    junit '**/build/test-results/**/TEST-*.xml'
+                    archiveArtifacts artifacts: 'tests/*/hs_err_pid*.log', allowEmptyArchive: true  // Only on JVM crash.
+                    recordIssues(tool: spotBugs(pattern: '**/build/reports/spotbugs/*.xml', useRankAsPriority: true))
+                }
+            }
+        }
+
+        // Test oldest supported and a recent JDK.
+        // Note: can not run these in parallel using a matrix configuration as Gradle would step over itself.
+        // Also shouldn't add agent config to avoid that as it triggers a separate job which can easily cause deadlocks.
+        stage("test-jdk-8") {
+            environment {
+                TEST_JDK = "8"
+            }
+            steps {
+                // "|| true" for an OK exit code if no file is found
+                sh 'rm tests/objectbox-java-test/hs_err_pid*.log || true'
+                // Note: do not run check task as it includes SpotBugs.
+                sh "./scripts/test-with-asan.sh $gradleArgs $gitlabRepoArgs clean :tests:objectbox-java-test:test"
+            }
+            post {
+                always {
+                    junit '**/build/test-results/**/TEST-*.xml'
+                    archiveArtifacts artifacts: 'tests/*/hs_err_pid*.log', allowEmptyArchive: true  // Only on JVM crash.
+                }
+            }
+        }
+        stage("test-jdk-16") {
+            environment {
+                TEST_JDK = "16"
+            }
+            steps {
+                // "|| true" for an OK exit code if no file is found
+                sh 'rm tests/objectbox-java-test/hs_err_pid*.log || true'
+                // Note: do not run check task as it includes SpotBugs.
+                sh "./scripts/test-with-asan.sh $gradleArgs $gitlabRepoArgs clean :tests:objectbox-java-test:test"
+            }
+            post {
+                always {
+                    junit '**/build/test-results/**/TEST-*.xml'
+                    archiveArtifacts artifacts: 'tests/*/hs_err_pid*.log', allowEmptyArchive: true  // Only on JVM crash.
+                }
             }
         }
 
         stage('upload-to-internal') {
             steps {
-                sh "./gradlew $gradleArgs $MVN_REPO_ARGS $MVN_REPO_UPLOAD_ARGS uploadArchives"
+                sh "./gradlew $gradleArgs $signingArgs $gitlabRepoArgs -PversionSuffix=$versionSuffix publishMavenJavaPublicationToGitLabRepository"
             }
         }
 
-        stage('upload-to-bintray') {
+        stage('upload-to-central') {
             when { expression { return isPublish } }
             environment {
-                BINTRAY_URL = credentials('bintray_url')
-                BINTRAY_LOGIN = credentials('bintray_login')
+                OSSRH_LOGIN = credentials('ossrh-login')
             }
             steps {
                 googlechatnotification url: 'id:gchat_java',
-                    message: "*Publishing* ${currentBuild.fullDisplayName} to Bintray...\n${env.BUILD_URL}"
+                    message: "*Publishing* ${currentBuild.fullDisplayName} to Central...\n${env.BUILD_URL}"
 
-                // Note: supply internal Maven repo as tests use native dependencies (can't publish those without the Java libraries).
-                // Note: add quotes around URL parameter to avoid line breaks due to semicolon in URL.
-                sh "./gradlew $gradleArgs $MVN_REPO_ARGS " +
-                   "\"-PpreferredRepo=${BINTRAY_URL}\" -PpreferredUsername=${BINTRAY_LOGIN_USR} -PpreferredPassword=${BINTRAY_LOGIN_PSW} " +
-                   "uploadArchives"
+                // Note: supply internal repo as tests use native dependencies that might not be published, yet.
+                sh "./gradlew $gradleArgs $signingArgs $gitlabRepoArgs $uploadRepoArgsCentral publishMavenJavaPublicationToSonatypeRepository closeAndReleaseStagingRepository"
 
                 googlechatnotification url: 'id:gchat_java',
-                    message: "Published ${currentBuild.fullDisplayName} successfully to Bintray - check https://bintray.com/objectbox/objectbox\n${env.BUILD_URL}"
+                    message: "Published ${currentBuild.fullDisplayName} successfully to Central - check https://repo1.maven.org/maven2/io/objectbox/ in a few minutes.\n${env.BUILD_URL}"
             }
         }
 
@@ -95,10 +133,6 @@ pipeline {
     // For global vars see /jenkins/pipeline-syntax/globals
     post {
         always {
-            junit '**/build/test-results/**/TEST-*.xml'
-            archiveArtifacts artifacts: 'tests/*/hs_err_pid*.log', allowEmptyArchive: true  // Only on JVM crash.
-            recordIssues(tool: spotBugs(pattern: '**/build/reports/spotbugs/*.xml', useRankAsPriority: true))
-
             googlechatnotification url: 'id:gchat_java', message: "${currentBuild.currentResult}: ${currentBuild.fullDisplayName}\n${env.BUILD_URL}",
                                    notifyFailure: 'true', notifyUnstable: 'true', notifyBackToNormal: 'true'
         }
@@ -123,6 +157,17 @@ pipeline {
 
         success {
             updateGitlabCommitStatus name: 'build', state: 'success'
+            script {
+                if (startedByTimer) {
+                    echo "Started by timer, not triggering integration tests"
+                } else {
+                  // Trigger integration tests in GitLab
+                  // URL configured like <host>/api/v4/projects/<id>/trigger/pipeline?token=<token>
+                  // Note: do not fail on error in case ref does not exist, only output response
+                  // --silent --show-error disable progress output but still show errors
+                  sh 'curl --silent --show-error -X POST "$GITLAB_INTEG_TESTS_TRIGGER_URL&ref=$GIT_BRANCH"'
+                }
+            }
         }
     }
 }
diff --git a/README.md b/README.md
index 0493b6e3..761ae1ad 100644
--- a/README.md
+++ b/README.md
@@ -1,107 +1,455 @@
-<img width="466" src="https://raw.githubusercontent.com/objectbox/objectbox-java/master/logo.png">
+<p align="center"><img width="466" src="https://raw.githubusercontent.com/objectbox/objectbox-java/master/logo.png" alt="ObjectBox"></p>
 
-# Do you ♥️ using ObjectBox?
-[![Follow ObjectBox on Twitter](https://img.shields.io/twitter/follow/ObjectBox_io.svg?style=flat-square&logo=twitter&color=fff)](https://twitter.com/ObjectBox_io)
+<p align="center">
+  <a href="https://docs.objectbox.io/getting-started">Getting Started</a> •
+  <a href="https://docs.objectbox.io">Documentation</a> •
+  <a href="https://github.com/objectbox/objectbox-examples">Example Apps</a> •
+  <a href="https://github.com/objectbox/objectbox-java/issues">Issues</a>
+</p>
 
-We want to [hear about your app](https://docs.google.com/forms/d/e/1FAIpQLScIYiOIThcq-AnDVoCvnZOMgxO4S-fBtDSFPQfWldJnhi2c7Q/viewform)!
-It will - literally - take just a minute, but help us a lot. Thank you!​ 🙏​
+<p align="center">
+  <a href="https://github.com/objectbox/objectbox-java/releases/latest">
+    <img src="https://img.shields.io/github/v/release/objectbox/objectbox-java?color=7DDC7D&style=flat-square" alt="Latest Release">
+  </a>
+  <a href="https://github.com/objectbox/objectbox-java/stargazers">
+    <img src="https://img.shields.io/github/stars/objectbox/objectbox-java?color=17A6A6&logo=github&style=flat-square" alt="Star objectbox-java">
+  </a>
+  <a href="https://github.com/objectbox/objectbox-java/blob/main/LICENSE.txt">
+    <img src="https://img.shields.io/github/license/objectbox/objectbox-java?color=7DDC7D&logo=apache&style=flat-square" alt="Apache 2.0 license">
+  </a>
+  <a href="https://twitter.com/ObjectBox_io">
+    <img src="https://img.shields.io/twitter/follow/objectbox_io?color=%20%2300aced&logo=twitter&style=flat-square" alt="Follow @ObjectBox_io">
+  </a>
+</p>
 
-# ObjectBox Java (Kotlin, Android)
-ObjectBox is a superfast object-oriented database with strong relation support.
-ObjectBox is embedded into your Android, Linux, macOS, or Windows app.
+# ObjectBox - Fast and Efficient Java Database (Android, JVM) with Vector Search
 
-**Latest version: [2.6.0 (2020/06/09)](https://docs.objectbox.io/#objectbox-changelog)**
+ObjectBox Java is a lightweight yet powerful on-device database & vector database designed specifically for **Java and Kotlin** applications.
+Store and manage data effortlessly in your Android or JVM Linux, macOS or Windows app with ObjectBox.
+Easily manage vector data alongside your objects and perform superfast on-device vector search to empower your apps with RAG AI, generative AI, and similarity search.
+Enjoy exceptional speed, battery-friendly resource usage, and environmentally-friendly development. 💚
 
-Demo code using ObjectBox:
+ObjectBox provides a store with boxes to put objects into:
+
+#### JVM + Java example
 
 ```java
-Playlist playlist = new Playlist("My Favorties");
-playlist.songs.add(new Song("Lalala"));
-playlist.songs.add(new Song("Lololo"));
-box.put(playlist);
+// Annotate a class to create a Box
+@Entity
+public class Person {
+  private @Id long id;
+  private String firstName;
+  private String lastName;
+
+  // Constructor, getters and setters left out for simplicity
+}
+ 
+BoxStore store = MyObjectBox.builder()
+        .name("person-db")
+        .build();
+ 
+Box<Person> box = store.boxFor(Person.class);
+ 
+Person person = new Person("Joe", "Green");
+long id = box.put(person);    // Create
+person = box.get(id);         // Read
+person.setLastName("Black");
+box.put(person);              // Update
+box.remove(person);           // Delete
 ```
 
-Other languages/bindings
-------------------------
-ObjectBox supports multiple platforms and languages.
-Besides JVM based languages like Java and Kotlin, ObjectBox also offers: 
+#### Android + Kotlin example
 
-* [ObjectBox Swift](https://github.com/objectbox/objectbox-swift): build fast mobile apps for iOS (and macOS) 
-* [ObjectBox Dart/Flutter](https://github.com/objectbox/objectbox-dart): cross-plattform for mobile and desktop apps (beta) 
-* [ObjectBox Go](https://github.com/objectbox/objectbox-go): great for data-driven tools and small server applications 
-* [ObjectBox C API](https://github.com/objectbox/objectbox-c): native speed with zero copy access to FlatBuffer objects
+```kotlin
+// Annotate a class to create a Box
+@Entity
+data class Person(
+    @Id var id: Long = 0,
+    var firstName: String? = null,
+    var lastName: String? = null
+)
+ 
+val store = MyObjectBox.builder()
+                .androidContext(context)
+                .build()
+ 
+val box = store.boxFor(Person::class)
+ 
+var person = Person(firstName = "Joe", lastName = "Green")
+val id = box.put()   // Create
+person = box.get(id) // Read
+person.lastName = "Black"
+box.put(person)     // Update
+box.remove(person)  // Delete
+```
 
-Gradle setup
-------------
-Add this to your root build.gradle (project level): 
+## Table of Contents
+
+- [Key Features](#key-features)
+- [Getting Started](#getting-started)
+  - [Gradle setup](#gradle-setup)
+  - [Maven setup](#maven-setup)
+- [Why use ObjectBox?](#why-use-objectbox-for-java-data-management)
+- [Community and Support](#community-and-support)
+- [Changelog](#changelog)
+- [Other languages/bindings](#other-languagesbindings)
+- [License](#license)
+
+## Key Features
+
+🧠 **First on-device vector database:** easily manage vector data and perform fast vector search
+🏁 **High performance:** exceptional speed, outperforming alternatives like SQLite and Realm in all CRUD operations.\
+💚 **Efficient Resource Usage:** minimal CPU, power and memory consumption for maximum flexibility and sustainability.\
+🔗 **[Built-in Object Relations](https://docs.objectbox.io/relations):** built-in support for object relations, allowing you to easily establish and manage relationships between objects.\
+👌 **Ease of use:** concise API that eliminates the need for complex SQL queries, saving you time and effort during development.
+
+## Getting Started
+
+> [!NOTE]
+> Prefer to look at example code? Check out [our examples repository](https://github.com/objectbox/objectbox-examples).
+
+You can add the ObjectBox Java SDK using a:
+
+- [Gradle setup](#gradle-setup)
+- [Maven setup](#maven-setup)
+
+ObjectBox tools and dependencies are available on [the Maven Central repository](https://central.sonatype.com/namespace/io.objectbox).
+
+The database libraries available for the ObjectBox Java SDK support:
+
+- JVM 8 or newer
+  - Linux (x64, arm64, armv7)
+  - macOS (x64, arm64)
+  - Windows (x64)
+- Android 5.0 (API level 21) or newer
+
+The ObjectBox Java SDK supports:
+
+- Java 8 or newer
+- Kotlin 1.7 or newer
+
+The [ObjectBox Gradle plugin](https://github.com/objectbox/objectbox-java-generator) supports:
+
+- Gradle 7.0 or newer
+- Android Gradle Plugin 8.1 or newer
+- JDK 11 or newer
+
+### Gradle setup
+
+For Gradle projects, add the required plugins to your root Gradle script.
+
+When using a [TOML version catalog](https://docs.gradle.org/current/userguide/version_catalogs.html) and plugins syntax 
+(for alternatives see below):
+          
+```toml
+# gradle/libs.versions.toml
+
+[versions]
+# For an Android project
+agp = "AGP_VERSION"
+# If using Kotlin
+kotlin = "KOTLIN_VERSION"
+
+# Define a variable for the version of the ObjectBox plugin
+objectbox = "6.0.0-beta"
+
+[plugins]
+# For an Android project, using Android Gradle Plugin 9.0 or newer
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-kapt = { id = "com.android.legacy-kapt", version.ref = "agp" }
+
+# For an Android project, using Android Gradle Plugin 8.13 or older
+android-application = { id = "com.android.application", version.ref = "agp" }
+kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+
+# For a JVM project, if using Kotlin 
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+kotlin-kapt = { id = "org.jetbrains.kotlin.kapt", version.ref = "kotlin" }
+
+# Add an alias for the ObjectBox plugin
+objectbox = { id = "io.objectbox", version.ref = "objectbox" }
+```
+
+```kotlin
+// build.gradle.kts
+
+plugins {
+    // For an Android project, using Android Gradle Plugin 9.0 or newer
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.kapt) apply false  
+  
+    // For an Android project, using Android Gradle Plugin 8.13 or older
+    alias(libs.plugins.android.application) apply false
+    alias(libs.plugins.kotlin.android) apply false
+    alias(libs.plugins.kotlin.kapt) apply false
+
+    // For a JVM project, if using Kotlin
+    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.kapt) apply false
+  
+    // Add the ObjectBox plugin
+    alias(libs.plugins.objectbox) apply false  
+}
+```
+
+```kotlin
+// settings.gradle.kts
+
+pluginManagement {
+    repositories {
+        // Add Maven Central to the plugin repositories
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
+```
+
+Then, in the Gradle script of your subproject apply the necessary plugins:
+
+```kotlin
+// app/build.gradle.kts
+
+plugins {
+    // For an Android project, using Android Gradle Plugin 9.0 or newer
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.kapt)
+    
+    // For an Android project, using Android Gradle Plugin 8.13 or older
+    alias(libs.plugins.android.application)
+    alias(libs.plugins.kotlin.android)
+    alias(libs.plugins.kotlin.kapt)
+    
+    // For a JVM project
+    id("application") // or id("java-library")
+    // Optional, if using Kotlin
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.kapt)
+
+    // Finally, apply the ObjectBox plugin
+    alias(libs.plugins.objectbox)
+}
+```
+
+Finally, sync the Gradle project with your IDE (for ex. using "Sync Project with Gradle Files" in Android Studio).
+
+Your project can now use ObjectBox, continue by [defining entity classes](https://docs.objectbox.io/getting-started#define-entity-classes).
+
+#### Alternatives
+
+<details><summary>Using plugins syntax with plugin IDs</summary>
+
+```kotlin
+// build.gradle.kts
+
+plugins {
+    // Add the ObjectBox plugin
+    id("io.objectbox") version "6.0.0-beta" apply false
+}
+```
+
+```kotlin
+// settings.gradle.kts
+
+pluginManagement {
+    repositories {
+        // Add Maven Central to the plugin repositories
+        mavenCentral()
+    }
+}
+
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
+```
+
+</details>
+
+<details><summary>Using buildscript syntax (KTS)</summary>
+
+```kotlin
+// build.gradle.kts
 
-```groovy
 buildscript {
-    ext.objectboxVersion = '2.6.0'
+    // Define a variable for the ObjectBox plugin version
+    val objectboxVersion by extra("6.0.0-beta")
+  
+    repositories {
+        // Add Maven Central to the plugin repositories     
+        mavenCentral()    
+    }
+  
     dependencies {
-        classpath "io.objectbox:objectbox-gradle-plugin:$objectboxVersion"
+        // Add the ObjectBox plugin
+        classpath("io.objectbox:objectbox-gradle-plugin:$objectboxVersion")
+    }
+}
+
+allprojects {
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
     }
 }
 ```
 
-And this to our app's build.gradle (module level):
+</details>
+
+<details><summary>Using buildscript syntax (Groovy)</summary>
 
 ```groovy
-apply plugin: 'io.objectbox' // after applying Android plugin
-```
+// build.gradle
 
-First steps
------------
-Create data object class `@Entity`, for example "Playlist".
-```java
-@Entity public class Playlist { ... }
+buildscript {
+    // Define a variable for the ObjectBox plugin version
+    ext.objectboxVersion = "6.0.0-beta"
+  
+    repositories {        
+        // Add Maven Central to the plugin repositories
+        mavenCentral()    
+    }
+  
+    dependencies {
+        // Add the ObjectBox plugin
+        classpath("io.objectbox:objectbox-gradle-plugin:$objectboxVersion")
+    }
+}
+
+allprojects {
+    repositories {
+        // Add Maven Central to the dependency repositories
+        mavenCentral()
+    }
+}
 ```
-Now build the project to let ObjectBox generate the class `MyObjectBox` for you.
 
-Prepare the BoxStore object once for your app, e.g. in `onCreate` in your Application class:
+</details>
 
-```java
-boxStore = MyObjectBox.builder().androidContext(this).build();
-```
+Then, in the Gradle script of your subproject apply the necessary plugins using their IDs:
 
-Then get a `Box` class for the Playlist entity class:
+```kotlin
+// app/build.gradle.kts
 
-```java
-Box<Playlist> box = boxStore.boxFor(Playlist.class);
+plugins {
+    // For an Android project, using Android Gradle Plugin 9.0 or newer
+    id("com.android.application") // or id("com.android.library")
+    id("com.android.legacy-kapt") 
+  
+    // For an Android project, using Android Gradle Plugin 8.13 or older
+    id("com.android.application") // or id("com.android.library")
+    id("org.jetbrains.kotlin.android") // or kotlin("android")
+    id("org.jetbrains.kotlin.kapt") // or kotlin("kapt")  
+  
+    // For a JVM project
+    id("application") // or id("java-library")
+    // Optional, if using Kotlin
+    id("org.jetbrains.kotlin.jvm") // or kotlin("jvm")
+    id("org.jetbrains.kotlin.kapt") // or kotlin("kapt")  
+
+    // Finally, apply the ObjectBox plugin
+    id("io.objectbox")
+}
 ```
 
-The `Box` object gives you access to all major functions, like `put`, `get`, `remove`, and `query`.
+### Maven setup
 
-For details please check the [docs](http://objectbox.io/documentation/).     
+This is currently only supported for JVM projects.
 
-Links
------
-[Features](https://objectbox.io/features/)
+To set up a Maven project, see the [README of the Java Maven example project](https://github.com/objectbox/objectbox-examples/blob/main/java-main-maven/README.md).
 
-[Docs & Changelog](https://docs.objectbox.io/), [JavaDocs](https://objectbox.io/docfiles/java/current/)
+## Frequently Asked Questions and Troubleshooting
 
-[Examples](https://github.com/objectbox/objectbox-examples)
+If you encounter any problems, check out the [FAQ](https://docs.objectbox.io/faq) and [Troubleshooting](https://docs.objectbox.io/troubleshooting) pages.
 
+## Why use ObjectBox for Java data management?
 
-We love to get your feedback
-----------------------------
-Let us know how we are doing: [2 minute questionnaire](https://docs.google.com/forms/d/e/1FAIpQLSe_fq-FlBThK_96bkHv1oEDizoHwEu_b6M4FJkMv9V5q_Or9g/viewform?usp=sf_link).
-Thanks!
+ObjectBox is a NoSQL Java database designed for local data storage on resource-restricted devices, prioritizing
+offline-first functionality. It is a smart and sustainable choice for local data persistence in Java and Kotlin
+applications. It offers efficiency, ease of use, and flexibility.
 
+### Fast but resourceful
 
-License
--------
-    Copyright 2017-2020 ObjectBox Ltd. All rights reserved.
-    
-    Licensed under the Apache License, Version 2.0 (the "License");
-    you may not use this file except in compliance with the License.
-    You may obtain a copy of the License at
-    
-        http://www.apache.org/licenses/LICENSE-2.0
-    
-    Unless required by applicable law or agreed to in writing, software
-    distributed under the License is distributed on an "AS IS" BASIS,
-    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-    See the License for the specific language governing permissions and
-    limitations under the License.
+Optimized for speed and minimal resource consumption, ObjectBox is an ideal solution for mobile devices. It has
+excellent performance, while also minimizing CPU, RAM, and power usage. ObjectBox outperforms SQLite and Realm across
+all CRUD (Create, Read, Update, Delete) operations. Check out our [Performance Benchmarking App repository](https://github.com/objectbox/objectbox-performance).
+
+### Simple but powerful
+
+With its concise language-native API, ObjectBox simplifies development by requiring less code compared to SQLite. It
+operates on plain objects (POJOs) with built-in relations, eliminating the need to manage rows and columns. This
+approach is efficient for handling large data volumes and allows for easy model modifications.
+
+### Functionality
+
+💐 **[Queries](https://docs.objectbox.io/queries):** filter data as needed, even across relations\
+💻 **[Multiplatform](https://docs.objectbox.io/faq#on-which-platforms-does-objectbox-run):** supports Android and JVM on Linux (also on ARM), Windows and macOS\
+🌱 **Scalable:** handling millions of objects resource-efficiently with ease\
+🦮 **Statically typed:** compile time checks & optimizations\
+📃 **Automatic schema migrations:** no update scripts needed
+
+**And much more than just data persistence**\
+🔄 **[ObjectBox Sync](https://objectbox.io/sync/):** keeps data in sync between devices and servers\
+🕒 **[ObjectBox TS](https://objectbox.io/time-series-database/):** time series extension for time based data
+
+## Community and Support
+
+❤ **Tell us what you think!** Share your thoughts through our [Anonymous Feedback Form](https://forms.gle/bdktGBUmL4m48ruj7).
+
+At ObjectBox, we are dedicated to bringing joy and delight to app developers by providing intuitive and fun-to-code-with
+APIs. We genuinely want to hear from you: What do you love about ObjectBox? What could be improved? Where do you face
+challenges in everyday app development?
+
+**We eagerly await your comments and requests, so please feel free to reach out to us:**
+
+- Add [GitHub issues](https://github.com/ObjectBox/objectbox-java/issues)
+- Upvote important issues 👍
+- Drop us a line via contact[at]objectbox.io
+- ⭐ us on GitHub if you like what you see!
+
+Thank you! Stay updated with our [blog](https://objectbox.io/blog).
+
+## Changelog
+
+For notable and important changes in new releases, read the [changelog](CHANGELOG.md).
+
+## Other languages/bindings
+
+ObjectBox supports multiple platforms and languages.
+Besides JVM based languages like Java and Kotlin, ObjectBox also offers:
+
+- [C and C++ SDK](https://github.com/objectbox/objectbox-c): native speed with zero copy access to FlatBuffer objects
+- [Dart and Flutter SDK](https://github.com/objectbox/objectbox-dart): cross-platform for mobile and desktop apps
+- [Go SDK](https://github.com/objectbox/objectbox-go): great for data-driven tools and embedded server applications
+- [Swift SDK](https://github.com/objectbox/objectbox-swift): build fast mobile apps for iOS (and macOS)
+
+## License
+
+```text
+Copyright 2017-2025 ObjectBox Ltd.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+```
 
+Note that this license applies to the code in this repository only.
+See our website on details about all [licenses for ObjectBox components](https://objectbox.io/faq/#license-pricing).
diff --git a/build-logic/README.md b/build-logic/README.md
new file mode 100644
index 00000000..06701235
--- /dev/null
+++ b/build-logic/README.md
@@ -0,0 +1,26 @@
+# Build logic project
+
+This project provides common build logic and is included as a composite build in
+the root settings file (as it provides plugins, in the `pluginManagement` block
+instead of before the usual include statements):
+
+```kotlin
+pluginManagement {
+    includeBuild("build-logic")
+}
+```
+
+## Convention Plugins
+
+- [objectbox.dokka-conventions](src/main/kotlin/objectbox.dokka-conventions.gradle.kts):
+  creates a "javadocJar" task that builds a JAR from HTML API docs generated by
+  Dokka
+- [objectbox.publishing-conventions](src/main/kotlin/objectbox.publishing-conventions.gradle.kts):
+  adds GitLab repo, configures common Maven POM values, configures signing of
+  artifacts
+
+## Related Gradle documentation
+
+- https://docs.gradle.org/current/userguide/composite_builds.html#included_plugin_builds
+- https://docs.gradle.org/current/userguide/best_practices_structuring_builds.html#use_convention_plugins
+- https://github.com/gradle/gradle/tree/master/platforms/documentation/docs/src/snippets/best-practices/useConventionPlugins-do
diff --git a/build-logic/build.gradle.kts b/build-logic/build.gradle.kts
new file mode 100644
index 00000000..8de1b45f
--- /dev/null
+++ b/build-logic/build.gradle.kts
@@ -0,0 +1,7 @@
+plugins {
+    `kotlin-dsl`
+}
+
+dependencies {
+    implementation(libs.buildLogic.dokka)
+}
diff --git a/build-logic/settings.gradle.kts b/build-logic/settings.gradle.kts
new file mode 100644
index 00000000..036a9328
--- /dev/null
+++ b/build-logic/settings.gradle.kts
@@ -0,0 +1,16 @@
+rootProject.name = "build-logic"
+
+// While this is an incubating API, it is the recommended way of declaring repositories:
+// https://docs.gradle.org/current/userguide/best_practices_dependencies.html#set_up_repositories_in_settings
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        mavenCentral()
+    }
+    // To avoid creating a separate version catalog in build-logic re-use the existing one
+    versionCatalogs {
+        create("libs") {
+            from(files("../gradle/libs.versions.toml"))
+        }
+    }
+}
diff --git a/build-logic/src/main/kotlin/objectbox.dokka-conventions.gradle.kts b/build-logic/src/main/kotlin/objectbox.dokka-conventions.gradle.kts
new file mode 100644
index 00000000..c72fd464
--- /dev/null
+++ b/build-logic/src/main/kotlin/objectbox.dokka-conventions.gradle.kts
@@ -0,0 +1,36 @@
+// This convention plugin creates a task named "javadocJar" that creates a JAR
+// from HTML API docs generated with Dokka suitable to publish to Maven Central.
+
+import org.gradle.jvm.tasks.Jar
+
+plugins {
+    id("org.jetbrains.dokka")
+}
+
+// Web API docs for objectbox-java packages, URL must end with a /
+private val javaApiDocsBaseUrl = "https://objectbox.io/docfiles/java/current/"
+// Note: In JDK 9+ the package-list file was renamed to element-list
+private val javaApiDocsPackageListUrl = "${javaApiDocsBaseUrl}element-list"
+
+// https://kotlinlang.org/docs/dokka-gradle-configuration-options.html
+dokka {
+    dokkaPublications.html {
+        outputDirectory.set(layout.buildDirectory.dir("docs/javadoc"))
+    }
+    dokkaSourceSets.configureEach {
+        // Create external links to ObjectBox Java API docs
+        externalDocumentationLinks.register("objectbox-java-docs") {
+            url(javaApiDocsBaseUrl)
+            packageListUrl(javaApiDocsPackageListUrl)
+        }
+    }
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    description = "Javadoc JAR containing HTML API docs generated by Dokka"
+    group = "build"
+    // Classifier as required by Maven Central
+    // https://central.sonatype.org/publish/requirements/#supply-javadoc-and-sources
+    archiveClassifier.set("javadoc")
+    from(tasks.dokkaGeneratePublicationHtml.flatMap { it.outputDirectory })
+}
diff --git a/build-logic/src/main/kotlin/objectbox.publishing-conventions.gradle.kts b/build-logic/src/main/kotlin/objectbox.publishing-conventions.gradle.kts
new file mode 100644
index 00000000..7215aa46
--- /dev/null
+++ b/build-logic/src/main/kotlin/objectbox.publishing-conventions.gradle.kts
@@ -0,0 +1,102 @@
+// This convention plugin expects some Gradle project properties to be set
+// (to set as environment variable prefix with ORG_GRADLE_PROJECT_):
+// https://docs.gradle.org/current/userguide/build_environment.html#sec:project_properties
+//
+// To publish artifacts to the internal GitLab repo set:
+// - gitlabUrl
+// - gitlabPublishToken: a token with permission to publish to the GitLab Package Repository
+// - gitlabPublishTokenName: optional, if set used instead of "Private-Token". Use for CI to specify e.g. "Job-Token".
+//
+// To sign artifacts using an ASCII encoded PGP key given via a file set:
+// - signingKeyFile
+// - signingKeyId
+// - signingPassword
+
+// Gradle properties
+val gitlabUrl = providers.gradleProperty("gitlabUrl")
+val gitlabPublishToken = providers.gradleProperty("gitlabPublishToken")
+val gitlabPublishTokenName = providers.gradleProperty("gitlabPublishTokenName")
+// The following properties are used for signing in CI using a key file
+val signingKeyFile = providers.gradleProperty("signingKeyFile")
+val signingKeyId = providers.gradleProperty("signingKeyId")
+val signingPassword = providers.gradleProperty("signingPassword")
+
+plugins {
+    id("maven-publish")
+    id("signing")
+}
+
+publishing {
+    repositories {
+        // If the applied to project has the required properties, configures the "GitLab" repository for publishing
+        // (Note: always adding it, even without credentials, so it's possible to see the tasks created for it.)
+        maven {
+            name = "GitLab"
+            if (gitlabUrl.isPresent && gitlabPublishToken.isPresent) {
+                // "https://gitlab.example.com/api/v4/projects/<PROJECT_ID>/packages/maven"
+                url = uri("${gitlabUrl.get()}/api/v4/projects/14/packages/maven")
+                credentials(HttpHeaderCredentials::class) {
+                    name = gitlabPublishTokenName.orNull ?: "Private-Token"
+                    value = gitlabPublishToken.get()
+                }
+                authentication {
+                    create<HttpHeaderAuthentication>("header")
+                }
+                println("Publishing: configured GitLab repository $url")
+            } else {
+                println("Publishing: GitLab repository NOT configured, see publishing-conventions plugin for required project properties")
+            }
+        }
+        // Note: Sonatype repo created by publish-plugin, see root build.gradle.kts.
+    }
+
+    publications {
+        // Common settings for all Maven publications
+        withType<MavenPublication> {
+            // Note: Projects set additional specific properties.
+            pom {
+                url.set("https://objectbox.io")
+                licenses {
+                    license {
+                        name.set("The Apache Software License, Version 2.0")
+                        url.set("https://www.apache.org/licenses/LICENSE-2.0.txt")
+                        distribution.set("repo")
+                    }
+                }
+                developers {
+                    developer {
+                        id.set("ObjectBox")
+                        name.set("ObjectBox")
+                    }
+                }
+                issueManagement {
+                    system.set("GitHub Issues")
+                    url.set("https://github.com/objectbox/objectbox-java/issues")
+                }
+                organization {
+                    name.set("ObjectBox Ltd.")
+                    url.set("https://objectbox.io")
+                }
+                scm {
+                    connection.set("scm:git@github.com:objectbox/objectbox-java.git")
+                    developerConnection.set("scm:git@github.com:objectbox/objectbox-java.git")
+                    url.set("https://github.com/objectbox/objectbox-java")
+                }
+            }
+        }
+    }
+}
+
+signing {
+    if (signingKeyFile.isPresent && signingKeyId.isPresent && signingPassword.isPresent) {
+        // Sign using an ASCII-armored key read from a file
+        // https://docs.gradle.org/current/userguide/signing_plugin.html#using_in_memory_ascii_armored_openpgp_subkeys
+        val keyFilePath = signingKeyFile.get()
+        val signingKey = File(keyFilePath).readText()
+        useInMemoryPgpKeys(signingKeyId.get(), signingKey, signingPassword.get())
+        println("Publishing: signing configured with key file $keyFilePath")
+    } else {
+        isRequired = false // Don't run sign tasks
+        println("Publishing: signing NOT configured, see publishing-conventions plugin for required project properties")
+    }
+}
diff --git a/build.gradle b/build.gradle
deleted file mode 100644
index ca14ec4c..00000000
--- a/build.gradle
+++ /dev/null
@@ -1,187 +0,0 @@
-buildscript {
-    ext {
-        // Typically, only edit those two:
-        def objectboxVersionNumber = '2.6.0' // without "-SNAPSHOT", e.g. '2.5.0' or '2.4.0-RC'
-        def objectboxVersionRelease = true  // set to true for releasing to ignore versionPostFix to avoid e.g. "-dev" versions
-
-        // version post fix: '-<value>' or '' if not defined; e.g. used by CI to pass in branch name
-        def versionPostFixValue = project.findProperty('versionPostFix')
-        def versionPostFix = versionPostFixValue ? "-$versionPostFixValue" : ''
-        ob_version = objectboxVersionNumber + (objectboxVersionRelease? "" : "$versionPostFix-SNAPSHOT")
-
-        // Native library version for tests
-        // Be careful to diverge here; easy to forget and hard to find JNI problems
-        def nativeVersion = objectboxVersionNumber + (objectboxVersionRelease? "": "-dev-SNAPSHOT")
-        def osName = System.getProperty("os.name").toLowerCase()
-        def objectboxPlatform = osName.contains('linux') ? 'linux'
-                : osName.contains("windows")? 'windows'
-                : osName.contains("mac")? 'macos'
-                : 'unsupported'
-        ob_native_dep = "io.objectbox:objectbox-$objectboxPlatform:$nativeVersion"
-
-        junit_version = '4.13'
-        mockito_version = '3.3.3'
-        kotlin_version = '1.3.72'
-        dokka_version = '0.10.1'
-
-        println "version=$ob_version"
-        println "objectboxNativeDependency=$ob_native_dep"
-    }
-
-    repositories {
-        mavenCentral()
-        jcenter()
-        maven {
-            url "https://plugins.gradle.org/m2/"
-        }
-    }
-
-    dependencies {
-        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-        classpath "org.jetbrains.dokka:dokka-gradle-plugin:$dokka_version"
-        classpath "gradle.plugin.com.github.spotbugs.snom:spotbugs-gradle-plugin:4.0.5"
-    }
-}
-
-allprojects {
-    group = 'io.objectbox'
-    version = ob_version
-
-    repositories {
-        mavenCentral()
-        jcenter()
-    }
-    
-    configurations.all {
-        resolutionStrategy.cacheChangingModulesFor 0, 'seconds'  // SNAPSHOTS
-    }
-}
-
-if (JavaVersion.current().isJava8Compatible()) {
-    allprojects {
-        tasks.withType(Javadoc) {
-            options.addStringOption('Xdoclint:none', '-quiet')
-        }
-    }
-}
-
-def projectNamesToPublish = [
-        'objectbox-java-api',
-        'objectbox-java',
-        'objectbox-kotlin',
-        'objectbox-rxjava',
-        'objectbox-rxjava3'
-]
-
-def hasSigningProperties() {
-    return (project.hasProperty('signingKeyId')
-            && project.hasProperty('signingKeyFile')
-            && project.hasProperty('signingPassword'))
-}
-
-configure(subprojects.findAll { projectNamesToPublish.contains(it.name) }) {
-    apply plugin: 'maven'
-    apply plugin: 'signing'
-
-    configurations {
-        deployerJars
-    }
-
-    dependencies {
-        // Using an older version to remain compatible with Wagon API used by Gradle/Maven
-        deployerJars 'org.apache.maven.wagon:wagon-webdav-jackrabbit:3.2.0'
-        deployerJars 'org.apache.maven.wagon:wagon-ftp:3.3.2'
-    }
-
-    signing {
-        if (hasSigningProperties()) {
-            String signingKey = new File(signingKeyFile).text
-            useInMemoryPgpKeys(signingKeyId, signingKey, signingPassword)
-            sign configurations.archives
-        } else {
-            println "Signing information missing/incomplete for ${project.name}"
-        }
-    }
-
-    // Use afterEvaluate or all dependencies will be lost in the generated POM
-    afterEvaluate {
-        uploadArchives {
-            repositories {
-                mavenDeployer {
-                    def preferredRepo = project.findProperty('preferredRepo')
-                    println "preferredRepo=$preferredRepo"
-                    
-                    if (preferredRepo == 'local') {
-                        repository url: repositories.mavenLocal().url
-                        println "Uploading archives to mavenLocal()."
-                    } else if (preferredRepo != null
-                            && project.hasProperty('preferredUsername') 
-                            && project.hasProperty('preferredPassword')) {
-                        if (!hasSigningProperties()) {
-                            throw new InvalidUserDataException("To upload to repo signing is required.")
-                        }
-
-                        configuration = configurations.deployerJars
-
-                        // replace placeholders
-                        def repositoryUrl = preferredRepo
-                                .replace('__groupId__', project.group)
-                                .replace('__artifactId__', project.archivesBaseName)
-                        repository(url: repositoryUrl) {
-                            authentication(userName: preferredUsername, password: preferredPassword)
-                        }
-
-                        println "Uploading archives to $repositoryUrl."
-                    } else if (project.hasProperty('sonatypeUsername')
-                            && project.hasProperty('sonatypePassword')) {
-                        beforeDeployment { MavenDeployment deployment -> signing.signPom(deployment) }
-
-                        def isSnapshot = version.endsWith('-SNAPSHOT')
-                        def sonatypeRepositoryUrl = isSnapshot
-                                ? "https://oss.sonatype.org/content/repositories/snapshots/"
-                                : "https://oss.sonatype.org/service/local/staging/deploy/maven2/"
-                        repository(url: sonatypeRepositoryUrl) {
-                            authentication(userName: sonatypeUsername, password: sonatypePassword)
-                        }
-
-                        println "Uploading archives to $sonatypeRepositoryUrl."
-                    } else {
-                        println "WARNING: preferredRepo or credentials NOT set, can not upload archives."
-                    }
-
-                    pom.project {
-                        packaging 'jar'
-                        url 'https://objectbox.io'
-
-                        scm {
-                            url 'https://github.com/objectbox/objectbox-java'
-                            connection 'scm:git@github.com:objectbox/objectbox-java.git'
-                            developerConnection 'scm:git@github.com:objectbox/objectbox-java.git'
-                        }
-
-                        developers {
-                            developer {
-                                id 'ObjectBox'
-                                name 'ObjectBox'
-                            }
-                        }
-
-                        issueManagement {
-                            system 'GitHub Issues'
-                            url 'https://github.com/objectbox/objectbox-java/issues'
-                        }
-
-                        organization {
-                            name 'ObjectBox Ltd.'
-                            url 'https://objectbox.io'
-                        }
-                    }
-                }
-            }
-        }
-    }
-}
-
-wrapper {
-    distributionType = Wrapper.DistributionType.ALL
-}
diff --git a/build.gradle.kts b/build.gradle.kts
new file mode 100644
index 00000000..a0791ce2
--- /dev/null
+++ b/build.gradle.kts
@@ -0,0 +1,128 @@
+/*
+ * This script supports some Gradle project properties:
+ *
+ * - versionSuffix: appended to snapshot version number, e.g. "1.2.3-<versionSuffix>-SNAPSHOT".
+ * Use to create different versions based on branch/tag.
+ * - sonatypeUsername: Maven Central credential used by Nexus publishing.
+ * - sonatypePassword: Maven Central credential used by Nexus publishing.
+ *
+ * This script supports the following environment variables:
+ *
+ * - OBX_RELEASE: If set to "true" builds and depends on release versions, without branch name and snapshot suffix.
+ */
+
+// Gradle properties (more defined in buildscript block below)
+val propertySonatypeUsername = providers.gradleProperty("sonatypeUsername")
+val propertySonatypePassword = providers.gradleProperty("sonatypePassword")
+
+plugins {
+    alias(libs.plugins.kotlin.jvm) apply false
+    alias(libs.plugins.kotlin.dokka) apply false
+    alias(libs.plugins.versions)
+    alias(libs.plugins.spotbugs) apply false
+    alias(libs.plugins.publish)
+    alias(libs.plugins.android.library) apply false
+}
+
+buildscript {
+    // Environment variables (see notes at the top of this file)
+    // https://docs.gitlab.com/ci/variables/predefined_variables/
+    val envIsCI: Boolean = System.getenv("CI") == "true"
+    val envRelease: String? = System.getenv("OBX_RELEASE")
+    // Gradle properties (see notes at the top of this file)
+    val propertyVersionSuffixName = "versionSuffix"
+    val propertyVersionSuffix = providers.gradleProperty(propertyVersionSuffixName)
+
+    // Version of Maven artifacts
+    // Should only be changed as part of the release process, see the release checklist in the objectbox repo
+    val versionNumber = "6.0.0-beta"
+
+    // If OBX_RELEASE is set, build and depend on release versions. Doesn't publish a release.
+    // See the release checklist in the objectbox repo on how to publish a release.
+    // If true, Maven artifacts use a release version, so without branch name and snapshot suffix
+    // (such as "-dev-SNAPSHOT"), including for dependencies (such as objectbox-java).
+    val isRelease = envRelease == "true"
+
+    if (!isRelease && envIsCI) {
+        throw GradleException("Publishing: property $propertyVersionSuffixName must be set in CI to calculate version suffix.")
+    }
+
+    // version suffix: "-<value>" or "" if not defined; e.g. used by CI to pass in branch name
+    val versionSuffix = if (propertyVersionSuffix.isPresent) "-${propertyVersionSuffix.get()}" else ""
+    val obxJavaVersion by extra(versionNumber + (if (isRelease) "" else "$versionSuffix-SNAPSHOT"))
+    println("Publishing: version = $obxJavaVersion")
+
+    // JVM and Android database library versions
+    val versionDbJvm = if (isRelease) versionNumber else "$versionNumber-dev-SNAPSHOT"
+    val versionDbJvmSync = if (isRelease) versionNumber else "$versionNumber-sync-SNAPSHOT"
+    val versionDbAndroid = if (isRelease) versionNumber else "$versionNumber-dev-SNAPSHOT"
+    val versionDbAndroidSync = if (isRelease) versionNumber else "$versionNumber-sync-SNAPSHOT"
+
+    println("Database dependencies (JVM) = $versionDbJvm")
+    println("Database dependencies (JVM + Sync) = $versionDbJvmSync")
+    println("Database dependencies (Android) = $versionDbAndroid")
+    println("Database dependencies (Android + Sync) = $versionDbAndroidSync")
+
+    val versionDatabaseLibraryJvm by extra(versionDbJvm)
+    val versionDatabaseLibraryJvmSync by extra(versionDbJvmSync)
+    val versionDatabaseLibraryAndroid by extra(versionDbAndroid)
+    val versionDatabaseLibraryAndroidSync by extra(versionDbAndroidSync)
+}
+
+allprojects {
+    group = "io.objectbox"
+    val obxJavaVersion: String by rootProject.extra
+    version = obxJavaVersion
+
+    configurations.all {
+        // Projects are using snapshot dependencies that may update more often than 24 hours.
+        resolutionStrategy {
+            cacheChangingModulesFor(0, "seconds")
+        }
+    }
+
+    tasks.withType<Javadoc>().configureEach {
+        // To support Unicode characters in API docs force the javadoc tool to use UTF-8 encoding.
+        // Otherwise, it defaults to the system file encoding. This is required even though setting file.encoding
+        // for the Gradle daemon (see gradle.properties) as Gradle does not pass it on to the javadoc tool.
+        options.encoding = "UTF-8"
+    }
+}
+
+// Exclude pre-release versions from dependencyUpdates task
+fun isNonStable(version: String): Boolean {
+    val stableKeyword = listOf("RELEASE", "FINAL", "GA").any { version.uppercase().contains(it) }
+    val regex = "^[0-9,.v-]+(-r)?$".toRegex()
+    val isStable = stableKeyword || regex.matches(version)
+    return isStable.not()
+}
+tasks.withType<com.github.benmanes.gradle.versions.updates.DependencyUpdatesTask> {
+    rejectVersionIf {
+        isNonStable(candidate.version)
+    }
+}
+
+tasks.wrapper {
+    distributionType = Wrapper.DistributionType.ALL
+}
+
+// Plugin to publish to Maven Central https://github.com/gradle-nexus/publish-plugin/
+// This plugin ensures a separate, named staging repo is created for each build when publishing.
+nexusPublishing {
+    this.repositories {
+        sonatype {
+            // Use the Portal OSSRH Staging API as this plugin does not support the new Portal API
+            // https://central.sonatype.org/publish/publish-portal-ossrh-staging-api/#configuring-your-plugin
+            nexusUrl.set(uri("https://ossrh-staging-api.central.sonatype.com/service/local/"))
+            snapshotRepositoryUrl.set(uri("https://central.sonatype.com/repository/maven-snapshots/"))
+
+            if (propertySonatypeUsername.isPresent && propertySonatypePassword.isPresent) {
+                println("Publishing: Maven Central credentials supplied")
+                username.set(propertySonatypeUsername.get())
+                password.set(propertySonatypePassword.get())
+            } else {
+                println("Publishing: Maven Central credentials NOT supplied, see root build script for required project properties")
+            }
+        }
+    }
+}
diff --git a/ci/Jenkinsfile-Windows b/ci/Jenkinsfile-Windows
index 31a69fe9..a663feb7 100644
--- a/ci/Jenkinsfile-Windows
+++ b/ci/Jenkinsfile-Windows
@@ -1,6 +1,12 @@
+#!/usr/bin/env groovy
+
 String buildsToKeep = '500'
 
-String gradleArgs = '-Dorg.gradle.daemon=false --stacktrace'
+String gradleArgs = '--stacktrace'
+boolean isPublish = BRANCH_NAME == 'publish'
+
+// Note: using single quotes to avoid Groovy String interpolation leaking secrets.
+def gitlabRepoArgsBat = '-PgitlabUrl=%GITLAB_URL% -PgitlabPrivateToken=%GITLAB_TOKEN%'
 
 // https://jenkins.io/doc/book/pipeline/syntax/
 pipeline {
@@ -8,16 +14,12 @@ pipeline {
     
     environment {
         GITLAB_URL = credentials('gitlab_url')
-        MVN_REPO_URL = credentials('objectbox_internal_mvn_repo_http')
-        MVN_REPO_LOGIN = credentials('objectbox_internal_mvn_user')
-        MVN_REPO_ARGS = "-PinternalObjectBoxRepo=$MVN_REPO_URL " +
-                        "-PinternalObjectBoxRepoUser=$MVN_REPO_LOGIN_USR " +
-                        "-PinternalObjectBoxRepoPassword=$MVN_REPO_LOGIN_PSW"
+        GITLAB_TOKEN = credentials('GITLAB_TOKEN_ALL')
     }
 
     options {
         buildDiscarder(logRotator(numToKeepStr: buildsToKeep, artifactNumToKeepStr: buildsToKeep))
-        gitLabConnection("${env.GITLAB_URL}")
+        gitLabConnection('objectbox-gitlab-connection')
     }
 
     triggers {
@@ -29,27 +31,60 @@ pipeline {
         stage('init') {
             steps {
                 bat 'gradlew -version'
+            }
+        }
 
-                // "cmd /c" for an OK exit code if no file is found
-                bat 'cmd /c del tests\\objectbox-java-test\\hs_err_pid*.log'
+        stage('build-java-x64') {
+            steps {
+                // Remove files to avoid archiving them again.
+                bat 'del /q /s hs_err_pid*.log'
+
+                bat "gradlew $gradleArgs $gitlabRepoArgsBat cleanTest build"
+            }
+            post {
+                always {
+                    junit '**/build/test-results/**/TEST-*.xml'
+                    archiveArtifacts artifacts: '**/hs_err_pid*.log', allowEmptyArchive: true
+                }
             }
         }
 
-        stage('build-java') {
+        stage('build-java-x86') {
+            environment {
+                // TEST_WITH_JAVA_X86 makes objectbox-java-test use 32-bit java executable and therefore
+                // 32-bit ObjectBox to run tests (see build.gradle file).
+                // Note: assumes JAVA_HOME_X86 is set to 32-bit JDK path.
+                TEST_WITH_JAVA_X86 = "true"
+            }
             steps {
-                bat "gradlew $gradleArgs $MVN_REPO_ARGS cleanTest build test"
+                // Remove files to avoid archiving them again.
+                bat 'del /q /s hs_err_pid*.log'
+
+                bat "gradlew $gradleArgs $gitlabRepoArgsBat cleanTest build"
+            }
+            post {
+                always {
+                    junit '**/build/test-results/**/TEST-*.xml'
+                    archiveArtifacts artifacts: '**/hs_err_pid*.log', allowEmptyArchive: true
+                }
+            }
+        }
+
+        stage('package-javadoc-for-web') {
+            when { expression { return isPublish } }
+            steps {
+                bat "gradlew $gradleArgs $gitlabRepoArgsBat :objectbox-java:packageJavadocForWeb"
+            }
+            post {
+                always {
+                    archiveArtifacts artifacts: 'objectbox-java/build/dist/objectbox-java-web-api-docs.zip'
+                }
             }
         }
     }
 
     // For global vars see /jenkins/pipeline-syntax/globals
     post {
-        always {
-            junit '**/build/test-results/**/TEST-*.xml'
-            archiveArtifacts artifacts: 'tests/*/hs_err_pid*.log', allowEmptyArchive: true  // Only on JVM crash.
-            // currently unused: archiveArtifacts '**/build/reports/findbugs/*'
-        }
-
         failure {
             updateGitlabCommitStatus name: 'build-windows', state: 'failed'
         }
diff --git a/ci/send-to-gchat.sh b/ci/send-to-gchat.sh
new file mode 100755
index 00000000..712221d7
--- /dev/null
+++ b/ci/send-to-gchat.sh
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+set -e
+
+if [[ "$#" -lt "2" ]]; then
+  echo "Please supply at least 2 parameters: gchat-webhook-url [--thread threadID] text"
+  echo "Text formatting: https://developers.google.com/chat/reference/message-formats/basic"
+  exit 1
+fi
+
+gchat_url=$1
+shift
+
+if [[ "$1" == "--thread" ]]; then
+  if [[ "$#" -lt "3" ]]; then
+    echo "Not enough parameters supplied"
+    exit 1
+  fi
+  #https://developers.google.com/chat/reference/rest/v1/spaces.messages/create
+  gchat_url="$gchat_url&threadKey=$2"
+  shift 2
+fi
+
+#https://developers.google.com/chat/reference/rest/v1/spaces.messages
+gchat_json="{\"text\": \"$*\"}"
+
+curl -X POST  -H 'Content-Type: application/json' "$gchat_url" -d "${gchat_json}" || true
diff --git a/ci/test-with-asan.sh b/ci/test-with-asan.sh
deleted file mode 100644
index 8220f44b..00000000
--- a/ci/test-with-asan.sh
+++ /dev/null
@@ -1,30 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-if [ -z "$ASAN_LIB_SO" ]; then
-    export ASAN_LIB_SO="$(find /usr/lib/llvm-7/ -name libclang_rt.asan-x86_64.so | head -1)"
-fi
-
-if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
-    export ASAN_SYMBOLIZER_PATH="$(find /usr/lib/llvm-7 -name llvm-symbolizer | head -1 )"
-fi
-
-if [ -z "$ASAN_OPTIONS" ]; then
-    export ASAN_OPTIONS="detect_leaks=0"
-fi
-
-echo "ASAN_LIB_SO: $ASAN_LIB_SO"
-echo "ASAN_SYMBOLIZER_PATH: $ASAN_SYMBOLIZER_PATH"
-echo "ASAN_OPTIONS: $ASAN_OPTIONS"
-ls -l $ASAN_LIB_SO
-ls -l $ASAN_SYMBOLIZER_PATH
-
-if [[ $# -eq 0 ]] ; then
-    args=test
-else
-    args=$@
-fi
-echo "Starting Gradle for target(s) \"$args\"..."
-pwd
-
-LD_PRELOAD=${ASAN_LIB_SO} ./gradlew ${args}
\ No newline at end of file
diff --git a/gradle.properties b/gradle.properties
new file mode 100644
index 00000000..481e0078
--- /dev/null
+++ b/gradle.properties
@@ -0,0 +1,15 @@
+# Gradle configuration
+# https://docs.gradle.org/current/userguide/build_environment.html
+
+# 1) Increase heap size from the default 512 MB for Android builds (using default value from Android
+# Studio project template).
+# https://docs.gradle.org/current/userguide/config_gradle.html#sec:configuring_jvm_memory
+# 2) To support Unicode characters in source code, set UTF-8 as the file encoding for the Gradle daemon,
+# which will make most Java tools use it instead of the default system file encoding. Note that for API docs,
+# the javadoc tool must be configured separately, see the root build script.
+# https://docs.gradle.org/current/userguide/common_caching_problems.html#system_file_encoding
+org.gradle.jvmargs=-Xmx2048m -Dfile.encoding=UTF-8
+
+# Android Plugin: use AndroidX dependencies
+# https://developer.android.com/jetpack/androidx/migrate
+android.useAndroidX=true
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
new file mode 100644
index 00000000..f6b25144
--- /dev/null
+++ b/gradle/libs.versions.toml
@@ -0,0 +1,76 @@
+[versions]
+# The versions of Gradle, Kotlin, Kotlin Coroutines and Android Gradle Plugin must be compatible.
+# Check
+# - https://kotlinlang.org/docs/gradle-configure-project.html#apply-the-plugin
+# - https://github.com/Kotlin/kotlinx.coroutines#readme
+# Note: when updating to a new minor version also have to increase the minimum
+# compiler and standard library version supported by consuming projects, see
+# objectbox-kotlin/ build script.
+# Note: if AGP Upgrade Assitant doesn't open, temporarily change to the com.android.application
+# plugin below. Also be aware that the latest version is likely not supported by IntelliJ IDEA.
+agp = "9.0.1" # https://developer.android.com/build/releases/gradle-plugin
+kotlin = "2.4.0"
+kotlin-coroutines = "1.11.0"
+# For objectbox-kotlin: a version of coroutines that depends on the same or older version of the
+# Kotlin standard library (org.jetbrains.kotlin:kotlin-stdlib) set as coreLibrariesVersion in its
+# build script. To find a suitable version, maybe use
+# https://mvnrepository.com/artifact/org.jetbrains.kotlinx/kotlinx-coroutines-core
+kotlin-coroutines-compat = "1.10.2" # 1.11.0 requires stdlib 2.2.20, so use 1.10.2
+# Dokka includes its own version of the Kotlin compiler, so it does not have to match the used
+# Kotlin version. But it might not understand new language features.
+kotlin-dokka = "2.2.0" # https://github.com/Kotlin/dokka/releases
+
+androidx-lifecycle = "2.6.1" # https://developer.android.com/jetpack/androidx/releases/lifecycle
+# Not using Paging v3 as it pulls in Kotlin
+androidx-paging = "2.1.2" # https://developer.android.com/jetpack/androidx/releases/paging
+androidx-test = "1.7.0" # https://developer.android.com/jetpack/androidx/releases/test
+androidx-test-junit = "1.3.0" # https://developer.android.com/jetpack/androidx/releases/test
+essentials = "3.1.0"
+jsr305 = "3.0.2"
+junit = "4.13.2"
+# Mockito 5 requires Java 11: this is fine as CI doesn't run RxJava tests with older JDKs
+mockito = "5.23.0" # https://github.com/mockito/mockito/releases/
+mockito-kotlin = "6.3.0" # https://github.com/mockito/mockito-kotlin/releases
+play-services-nearby = "19.3.0" # https://developers.google.com/android/guides/releases
+publish-plugin = "2.0.0" # https://github.com/gradle-nexus/publish-plugin/releases
+robolectric = "4.16.1" # https://github.com/robolectric/robolectric/releases
+rxjava2 = "2.2.21"
+rxjava3 = "3.0.11"
+spotbugs-annotations = "4.10.2" # https://github.com/spotbugs/spotbugs/blob/master/CHANGELOG.md
+spotbugs-plugin = "6.5.8" # https://github.com/spotbugs/spotbugs-gradle-plugin/releases
+turbine = "1.2.1" # https://github.com/cashapp/turbine/releases
+versions = "0.54.0" # https://github.com/ben-manes/gradle-versions-plugin/releases
+
+[libraries]
+androidx-lifecycle-livedata = { module = "androidx.lifecycle:lifecycle-livedata", version.ref = "androidx-lifecycle" }
+androidx-paging-runtime = { module = "androidx.paging:paging-runtime", version.ref = "androidx-paging" }
+androidx-test-core = { module = "androidx.test:core", version.ref = "androidx-test" }
+androidx-test-junit = { module = "androidx.test.ext:junit", version.ref = "androidx-test-junit" }
+androidx-test-rules = { module = "androidx.test:rules", version.ref = "androidx-test" }
+essentials = { module = "org.greenrobot:essentials", version.ref = "essentials" }
+jsr305 = { module = "com.google.code.findbugs:jsr305", version.ref = "jsr305" }
+junit = { module = "junit:junit", version.ref = "junit" }
+#noinspection SimilarGradleDependency
+kotlin-coroutines-core = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines" }
+#noinspection SimilarGradleDependency
+kotlin-coroutines-core-compat = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-core", version.ref = "kotlin-coroutines-compat" }
+kotlin-coroutines-test = { module = "org.jetbrains.kotlinx:kotlinx-coroutines-test", version.ref = "kotlin-coroutines" }
+mockito = { module = "org.mockito:mockito-core", version.ref = "mockito" }
+mockito-kotlin = { module = "org.mockito.kotlin:mockito-kotlin", version.ref = "mockito-kotlin" }
+play-services-nearby = { module = "com.google.android.gms:play-services-nearby", version.ref = "play-services-nearby" }
+robolectric = { module = "org.robolectric:robolectric", version.ref = "robolectric" }
+rxjava2 = { module = "io.reactivex.rxjava2:rxjava", version.ref = "rxjava2" }
+rxjava3 = { module = "io.reactivex.rxjava3:rxjava", version.ref = "rxjava3" }
+spotbugs-annotations = { module = "com.github.spotbugs:spotbugs-annotations", version.ref = "spotbugs-annotations" }
+turbine = { module = "app.cash.turbine:turbine", version.ref = "turbine" }
+
+# build-logic dependencies
+buildLogic-dokka = { module = "org.jetbrains.dokka:dokka-gradle-plugin", version.ref = "kotlin-dokka" }
+
+[plugins]
+android-library = { id = "com.android.library", version.ref = "agp" }
+kotlin-dokka = { id = "org.jetbrains.dokka", version.ref = "kotlin-dokka" }
+kotlin-jvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
+publish = { id = "io.github.gradle-nexus.publish-plugin", version.ref = "publish-plugin" }
+spotbugs = { id = "com.github.spotbugs", version.ref = "spotbugs-plugin" }
+versions = { id = "com.github.ben-manes.versions", version.ref = "versions" }
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 490fda85..b1b8ef56 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 6623300b..e74c8700 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,5 +1,9 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-6.3-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.5.1-all.zip
+networkTimeout=10000
+retries=0
+retryBackOffMs=500
+validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
diff --git a/gradlew b/gradlew
index 2fe81a7d..b9bb139f 100755
--- a/gradlew
+++ b/gradlew
@@ -1,7 +1,7 @@
-#!/usr/bin/env sh
+#!/bin/sh
 
 #
-# Copyright 2015 the original author or authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,80 +15,114 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
-##
-##  Gradle start up script for UN*X
-##
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/3d91ce3b8caaf77ad09f381f43615b715b53f72c/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
 ##############################################################################
 
 # Attempt to set APP_HOME
+
 # Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
 done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >/dev/null
-APP_HOME="`pwd -P`"
-cd "$SAVED" >/dev/null
 
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
+MAX_FD=maximum
 
 warn () {
     echo "$*"
-}
+} >&2
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-}
+} >&2
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=true
-    ;;
-  NONSTOP* )
-    nonstop=true
-    ;;
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
 
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD="$JAVA_HOME/jre/sh/java"
+        JAVACMD=$JAVA_HOME/jre/sh/java
     else
-        JAVACMD="$JAVA_HOME/bin/java"
+        JAVACMD=$JAVA_HOME/bin/java
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -97,87 +131,118 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD="java"
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    MAX_FD_LIMIT=`ulimit -H -n`
-    if [ $? -eq 0 ] ; then
-        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            MAX_FD="$MAX_FD_LIMIT"
-        fi
-        ulimit -n $MAX_FD
-        if [ $? -ne 0 ] ; then
-            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        fi
-    else
-        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-    fi
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
 fi
 
-# For Darwin, add options to specify how the application appears in the dock
-if $darwin; then
-    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-fi
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
 
 # For Cygwin or MSYS, switch paths to Windows format before running java
-if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then
-    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-    JAVACMD=`cygpath --unix "$JAVACMD"`
-
-    # We build the pattern for arguments to be converted via cygpath
-    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-    SEP=""
-    for dir in $ROOTDIRSRAW ; do
-        ROOTDIRS="$ROOTDIRS$SEP$dir"
-        SEP="|"
-    done
-    OURCYGPATTERN="(^($ROOTDIRS))"
-    # Add a user-defined pattern to the cygpath arguments
-    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-    fi
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
     # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    i=0
-    for arg in "$@" ; do
-        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-
-        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        else
-            eval `echo args$i`="\"$arg\""
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
         fi
-        i=`expr $i + 1`
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
     done
-    case $i in
-        0) set -- ;;
-        1) set -- "$args0" ;;
-        2) set -- "$args0" "$args1" ;;
-        3) set -- "$args0" "$args1" "$args2" ;;
-        4) set -- "$args0" "$args1" "$args2" "$args3" ;;
-        5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
-        6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
-        7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
-        8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
-        9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
-    esac
 fi
 
-# Escape application args
-save () {
-    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
-    echo " "
-}
-APP_ARGS=`save "$@"`
 
-# Collect all arguments for the java command, following the shell quoting and substitution rules
-eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
 
 exec "$JAVACMD" "$@"
diff --git a/gradlew.bat b/gradlew.bat
index 62bd9b9c..24c62d56 100644
--- a/gradlew.bat
+++ b/gradlew.bat
@@ -13,19 +13,22 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
 @rem
 @rem ##########################################################################
 
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
+@rem Set local scope for the variables, and ensure extensions are enabled
+setlocal EnableExtensions
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,64 +43,40 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto init
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
-goto fail
+"%COMSPEC%" /c exit 1
 
 :findJavaFromJavaHome
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto init
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:init
-@rem Get command-line arguments, handling Windows variants
-
-if not "%OS%" == "Windows_NT" goto win9xME_args
+if exist "%JAVA_EXE%" goto execute
 
-:win9xME_args
-@rem Slurp the command line arguments.
-set CMD_LINE_ARGS=
-set _SKIP=2
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
-:win9xME_args_slurp
-if "x%~1" == "x" goto execute
-
-set CMD_LINE_ARGS=%*
+"%COMSPEC%" /c exit 1
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
-
-@rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 
-:end
-@rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
 
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
+@rem Execute Gradle
+@rem endlocal doesn't take effect until after the line is parsed and variables are expanded
+@rem which allows us to clear the local environment before executing the java command
+endlocal & "%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %* & call :exitWithErrorLevel
 
-:omega
+:exitWithErrorLevel
+@rem Use "%COMSPEC%" /c exit to allow operators to work properly in scripts
+"%COMSPEC%" /c exit %ERRORLEVEL%
diff --git a/objectbox-android/README.md b/objectbox-android/README.md
new file mode 100644
index 00000000..266ea777
--- /dev/null
+++ b/objectbox-android/README.md
@@ -0,0 +1,24 @@
+# ObjectBox Android APIs
+
+Builds Android libraries (AAR) published as Maven artifacts to [use ObjectBox on Android](../README.md#getting-started).
+
+Each Android library contains Android-specific ObjectBox APIs and has a dependency on a matching Android database library.
+
+Available public APIs:
+
+- [Admin](src/adminIncluded/java/io/objectbox/android/Admin.java): API to use the [Admin web app on Android](https://docs.objectbox.io/data-browser#admin-for-android)
+- [AndroidScheduler](src/main/java/io/objectbox/android/AndroidScheduler.java): can be used to [observe query results](https://docs.objectbox.io/data-observers-and-rx#thread-scheduling) on the Android main thread
+- [ObjectBoxDataSource](src/main/java/io/objectbox/android/ObjectBoxDataSource.java): reference implementation of a data source for the AndroidX paging library
+- [ObjectBoxLiveData](src/main/java/io/objectbox/android/ObjectBoxLiveData.java): reference implementation of an AndroidX LiveData
+
+The following Maven artifacts are currently published by this project:
+
+| Artifact ID                            | Admin                                              | Android database library |
+|----------------------------------------|----------------------------------------------------|--------------------------|
+| `objectbox-android`                    | no-op API                                          | Basic                    |
+| `objectbox-android-objectbrowser`      | API, [resources][res], [custom manifest][manifest] | Basic + Admin            |
+| `objectbox-sync-android`               | no-op API                                          | Sync                     |
+| `objectbox-sync-android-objectbrowser` | API, [resources][res], [custom manifest][manifest] | Sync + Admin             |
+
+[manifest]: src/adminIncluded/AndroidManifest.xml
+[res]: src/adminIncluded/res
diff --git a/objectbox-android/build.gradle.kts b/objectbox-android/build.gradle.kts
new file mode 100644
index 00000000..d24e12c5
--- /dev/null
+++ b/objectbox-android/build.gradle.kts
@@ -0,0 +1,239 @@
+import org.gradle.kotlin.dsl.support.uppercaseFirstChar
+
+
+plugins {
+    alias(libs.plugins.android.library)
+    id("objectbox.publishing-conventions")
+}
+
+val flavorAdminExcluded = "adminExcluded"
+val flavorAdminIncluded = "adminIncluded"
+val flavorBasic = "basic"
+val flavorSync = "sync"
+// Note: build variant names also match names of created components
+val variantAdminExcludedBasicRelease = "${flavorAdminExcluded}${flavorBasic.uppercaseFirstChar()}Release"
+val variantAdminIncludedBasicRelease = "${flavorAdminIncluded}${flavorBasic.uppercaseFirstChar()}Release"
+val variantAdminExcludedSyncRelease = "${flavorAdminExcluded}${flavorSync.uppercaseFirstChar()}Release"
+val variantAdminIncludedSyncRelease = "${flavorAdminIncluded}${flavorSync.uppercaseFirstChar()}Release"
+
+android {
+    namespace = "io.objectbox.android"
+    // Note: increasing compile SDK also signals this library is compatible with any changes in that
+    // API level, see "behavior changes" for each Android version at https://developer.android.com/about/versions
+    // Due to an oversight previous versions of this library relied on the ignored, now removed,
+    // target SDK property. So this library actually only supports up to Android 13. But as only
+    // the Admin foreground helper service is broken (on Android 14 and up, see objectbox-java#226)
+    // keeping at SDK 35.
+    compileSdk = 35 // Android 15 (Vanilla Ice Cream)
+
+    // Not using Kotlin source code, so prevent the Kotlin standard library from getting added,
+    // avoid Kotlin compiler task run.
+    enableKotlin = false
+
+    // Common configuration for all variants (variant = flavor + build type).
+    defaultConfig {
+        minSdk = 21 // Android 5.0 (Lollipop), the minimum of NDK r27 used by the database library
+
+        consumerProguardFiles("consumer-proguard-rules.pro")
+    }
+
+    signingConfigs {
+        getByName("debug") {
+            storeFile = file(System.getProperty("user.home") + "/.android/debug.keystore")
+        }
+    }
+
+    // https://developer.android.com/studio/build/build-variants#build-types
+    // Common configuration for release build types (debug currently left at default).
+    buildTypes {
+        release {
+            // Currently not obfuscating/minifying with ProGuard/R8.
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro")
+            // Just to use without checkjni
+            signingConfig = signingConfigs.getByName("debug")
+        }
+    }
+
+    // Configure a flavor dimension based on if Admin is included in the Android database library.
+    // The Admin included flavor adds additional source files, resources and a different Android
+    // manifest to help using Admin. The excluded flavor adds source files with no-op Admin APIs.
+    // See the directories in "src/" named like the flavors.
+    // Configure another flavor dimension purely to add a regular or a Sync variant of the Android
+    // database library dependency. See the dependencies block.
+    // Note: common configuration defined in defaultConfig and buildTypes blocks above.
+    // https://developer.android.com/studio/build/build-variants#product-flavors
+    val dimensionAdmin = "admin"
+    val dimensionDatabase = "database"
+    flavorDimensions += listOf(dimensionAdmin, dimensionDatabase)
+    productFlavors {
+        create(flavorAdminExcluded) {
+            dimension = dimensionAdmin
+        }
+        create(flavorAdminIncluded) {
+            dimension = dimensionAdmin
+            // Set Admin included flavor as default in Android Studio as it's most likely to display
+            // errors on breaking changes to the Java API dependency.
+            isDefault = true
+        }
+        create(flavorBasic) {
+            dimension = dimensionDatabase
+        }
+        create(flavorSync) {
+            dimension = dimensionDatabase
+        }
+    }
+
+    // Publish the release variants (variant = flavor combination + build type)
+    // https://developer.android.com/studio/publish-library/configure-pub-variants
+    publishing {
+        singleVariant(variantAdminExcludedBasicRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminIncludedBasicRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminExcludedSyncRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminIncludedSyncRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+    }
+
+    // Java 8 features support https://developer.android.com/studio/write/java8-support
+    // Note: this requires consuming projects to also enable this.
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    lint {
+        // Due to an oversight (see notes on compileSdk above) AdminKeepAliveService is not
+        // compatible with Android 14, temporarily ignore the error lint produces as a result.
+        disable += "ForegroundServiceType"
+    }
+
+    // For local unit tests enable use of Android framework with Robolectric
+    testOptions {
+        unitTests.isIncludeAndroidResources = true
+    }
+}
+
+val versionDatabaseLibraryAndroid: String by rootProject.extra
+val versionDatabaseLibraryAndroidSync: String by rootProject.extra
+
+// Must manually create configurations for flavor combinations to add dependencies
+// (they are still picked up automatically by the Android plugin).
+// https://developer.android.com/build/dependencies#configure_dependencies_for_a_specific_build_variant
+val adminExcludedBasicImplementation by configurations.creating
+val adminIncludedBasicImplementation by configurations.creating
+val adminExcludedSyncImplementation by configurations.creating
+val adminIncludedSyncImplementation by configurations.creating
+
+dependencies {
+    // Use "api" to add the Java library as a "compile" dependency in the POM as this library
+    // exposes APIs from it (such as Scheduler in AndroidScheduler, BoxStore in Admin). Regardless,
+    // it is expected that most consumers (or the Gradle plugin) add the Java library as a direct
+    // dependency.
+    api(project(":objectbox-java"))
+    // Use "implementation" to add the database library as a "runtime" dependency in the POM as it
+    // has no Java APIs to expose.
+    adminExcludedBasicImplementation("io.objectbox:objectbox-android-db:$versionDatabaseLibraryAndroid")
+    adminIncludedBasicImplementation("io.objectbox:objectbox-android-db-admin:$versionDatabaseLibraryAndroid")
+    adminExcludedSyncImplementation("io.objectbox:objectbox-sync-android-db:$versionDatabaseLibraryAndroidSync")
+    adminIncludedSyncImplementation("io.objectbox:objectbox-sync-android-db-admin:$versionDatabaseLibraryAndroidSync")
+
+    // Use "compileOnly" to not add these as dependencies in the POM to avoid consumer projects
+    // pulling in unused dependencies. It is expected that consumers did already add these
+    // dependencies when using related classes of this library.
+    compileOnly(libs.androidx.lifecycle.livedata)
+    compileOnly(libs.androidx.paging.runtime)
+
+    // Dependencies for unit tests running on the JVM (so not on an Android device/emulator)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.androidx.test.rules)
+    testImplementation(libs.junit)
+    testImplementation(libs.androidx.test.junit)
+    testImplementation(libs.robolectric)
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxAndroid = "objectboxAndroid"
+val publicationObjectboxAndroidObjectbrowser = "objectboxAndroidObjectbrowser"
+val publicationObjectboxSyncAndroid = "objectboxSyncAndroid"
+val publicationObjectboxSyncAndroidObjectbrowser = "objectboxSyncAndroidObjectbrowser"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxAndroid) {
+            artifactId = "objectbox-android"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminExcludedBasicRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android")
+            }
+        }
+        create<MavenPublication>(publicationObjectboxAndroidObjectbrowser) {
+            artifactId = "objectbox-android-objectbrowser"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminIncludedBasicRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android with Admin")
+            }
+        }
+        create<MavenPublication>(publicationObjectboxSyncAndroid) {
+            artifactId = "objectbox-sync-android"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminExcludedSyncRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android with Sync")
+            }
+        }
+        create<MavenPublication>(publicationObjectboxSyncAndroidObjectbrowser) {
+            artifactId = "objectbox-sync-android-objectbrowser"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminIncludedSyncRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Android with Admin and Sync")
+            }
+        }
+        // Additional common configuration for all Maven publications
+        withType<MavenPublication> {
+            pom {
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "aar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxAndroid])
+    sign(publishing.publications[publicationObjectboxAndroidObjectbrowser])
+    sign(publishing.publications[publicationObjectboxSyncAndroid])
+    sign(publishing.publications[publicationObjectboxSyncAndroidObjectbrowser])
+}
diff --git a/objectbox-android/consumer-proguard-rules.pro b/objectbox-android/consumer-proguard-rules.pro
new file mode 100644
index 00000000..bff3c650
--- /dev/null
+++ b/objectbox-android/consumer-proguard-rules.pro
@@ -0,0 +1,10 @@
+# When editing this file, also look at objectbox-java.pro of objectbox-java.
+
+# Accessed by objectbox-java through reflection.
+-keep class io.objectbox.android.internal.AndroidPlatform {*;}
+
+# For provided android.arch.lifecycle:extensions
+-dontwarn io.objectbox.android.ObjectBoxLiveData
+
+# For provided android.arch.paging:runtime
+-dontwarn io.objectbox.android.ObjectBoxDataSource*
diff --git a/objectbox-android/proguard-rules.pro b/objectbox-android/proguard-rules.pro
new file mode 100644
index 00000000..481bb434
--- /dev/null
+++ b/objectbox-android/proguard-rules.pro
@@ -0,0 +1,21 @@
+# Add project specific ProGuard rules here.
+# You can control the set of applied configuration files using the
+# proguardFiles setting in build.gradle.
+#
+# For more details, see
+#   http://developer.android.com/guide/developing/tools/proguard.html
+
+# If your project uses WebView with JS, uncomment the following
+# and specify the fully qualified class name to the JavaScript interface
+# class:
+#-keepclassmembers class fqcn.of.javascript.interface.for.webview {
+#   public *;
+#}
+
+# Uncomment this to preserve the line number information for
+# debugging stack traces.
+#-keepattributes SourceFile,LineNumberTable
+
+# If you keep the line number information, uncomment this to
+# hide the original source file name.
+#-renamesourcefileattribute SourceFile
\ No newline at end of file
diff --git a/objectbox-android/src/adminExcluded/java/io/objectbox/android/Admin.java b/objectbox-android/src/adminExcluded/java/io/objectbox/android/Admin.java
new file mode 100644
index 00000000..f1f12487
--- /dev/null
+++ b/objectbox-android/src/adminExcluded/java/io/objectbox/android/Admin.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2022 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.Context;
+
+import io.objectbox.BoxStore;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new Admin(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ */
+public class Admin {
+
+    private int notificationId;
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public Admin(BoxStore boxStore) {
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public int getNotificationId() {
+        return notificationId;
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public void setNotificationId(int notificationId) {
+        this.notificationId = notificationId;
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public boolean start(Context context) {
+        return false;
+    }
+
+}
diff --git a/objectbox-android/src/adminExcluded/java/io/objectbox/android/AndroidObjectBrowser.java b/objectbox-android/src/adminExcluded/java/io/objectbox/android/AndroidObjectBrowser.java
new file mode 100644
index 00000000..f5651a56
--- /dev/null
+++ b/objectbox-android/src/adminExcluded/java/io/objectbox/android/AndroidObjectBrowser.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.Context;
+
+import io.objectbox.BoxStore;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new AndroidObjectBrowser(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ *
+ * @deprecated Use {@link Admin} instead.
+ */
+@Deprecated
+public class AndroidObjectBrowser extends Admin {
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public AndroidObjectBrowser(BoxStore boxStore) {
+        super(boxStore);
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public int getNotificationId() {
+        return super.getNotificationId();
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public void setNotificationId(int notificationId) {
+        super.setNotificationId(notificationId);
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public boolean start(Context context) {
+        return super.start(context);
+    }
+}
diff --git a/objectbox-android/src/adminIncluded/AndroidManifest.xml b/objectbox-android/src/adminIncluded/AndroidManifest.xml
new file mode 100644
index 00000000..508901c5
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/AndroidManifest.xml
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Note that the objectbox-android AAR ships a different manifest! -->
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <!-- When targeting API level 28 or higher to run ObjectBox Admin foreground service -->
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <!-- When targeting API level 33 or higher to post the initial ObjectBox Admin notification -->
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS"/>
+
+    <application>
+        <!-- ObjectBox Admin -->
+        <service
+            android:name=".AdminKeepAliveService"
+            android:exported="false" />
+
+        <receiver
+            android:name=".AdminNotificationReceiver"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="io.objectbox.action.KEEP_ALIVE" />
+            </intent-filter>
+        </receiver>
+    </application>
+
+</manifest>
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/Admin.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/Admin.java
new file mode 100644
index 00000000..5bad3ddb
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/Admin.java
@@ -0,0 +1,194 @@
+/*
+ * Copyright 2022 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Process;
+import android.util.Log;
+
+import io.objectbox.BoxStore;
+
+import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new Admin(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ */
+public class Admin {
+
+    private static final String TAG = "ObjectBoxAdmin";
+    private static final String NOTIFICATION_CHANNEL_ID = "objectbox-browser";
+
+    private final BoxStore boxStore;
+    private int notificationId;
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public Admin(BoxStore boxStore) {
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public int getNotificationId() {
+        return notificationId;
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     */
+    public void setNotificationId(int notificationId) {
+        this.notificationId = notificationId;
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link Admin class documentation} for details.
+     */
+    public boolean start(Context context) {
+        if (!BoxStore.isObjectBrowserAvailable()) {
+            return false;
+        }
+
+        // compare with objectbox-android-objectbrowser/src/main/AndroidManifest.xml
+        // SecurityException if no INTERNET permission
+        context.enforcePermission(Manifest.permission.INTERNET, Process.myPid(), Process.myUid(), null);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
+                && context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.P) {
+            // SecurityException if no FOREGROUND_SERVICE permission
+            context.enforcePermission(Manifest.permission.FOREGROUND_SERVICE, Process.myPid(), Process.myUid(), null);
+        }
+
+        int alreadyRunningPort = boxStore.getObjectBrowserPort();
+        if (alreadyRunningPort != 0) {
+            Log.w(TAG, "ObjectBox Admin is already running at port " + alreadyRunningPort);
+            return false;
+        }
+        String url = boxStore.startObjectBrowser();
+        if (url == null) {
+            return false;
+        }
+        Log.i(TAG, "ObjectBox Admin running at URL: " + url);
+        int port = boxStore.getObjectBrowserPort();
+        Log.i(TAG, "To access the ObjectBox Admin URL on your machine run: adb forward tcp:" + port + " tcp:" + port);
+
+
+        if (notificationId == 0) {
+            notificationId = 19770000 + port;
+        }
+
+        // build intent and show notification
+        Intent intent = new Intent(context, AdminNotificationReceiver.class);
+        intent.setAction(AdminNotificationReceiver.ACTION_KEEP_ALIVE);
+        intent.putExtra(AdminKeepAliveService.EXTRA_KEY_URL, url);
+        intent.putExtra(AdminKeepAliveService.EXTRA_KEY_PORT, port);
+        intent.putExtra(AdminKeepAliveService.EXTRA_KEY_NOTIFICATION_ID, notificationId);
+        PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent,
+                buildPendingIntentFlags(PendingIntent.FLAG_CANCEL_CURRENT));
+
+        NotificationManager manager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        // Note: may be null in case where notification service is not available on device (e.g. custom Android OS).
+        if (manager != null) {
+            // On Android 13 or newer notifications for apps are turned off by default,
+            // developers need to turn on notifications for the app through system settings
+            // or request the permission from the user.
+            // https://developer.android.com/develop/ui/views/notifications/notification-permission
+            // Already on Android 7 or newer, notifications can been turned off in system settings. This may happen
+            // while developers are testing an app, so also warn in this case.
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && !manager.areNotificationsEnabled()) {
+                Log.w(TAG, "To use the ObjectBox Admin keep-alive notification turn on notifications for this app");
+            }
+            Notification.Builder builder = buildBaseNotification(context, port, manager);
+            builder.setContentIntent(pendingIntent);
+            manager.notify(notificationId, builder.build());
+        }
+
+        return true;
+    }
+
+    static Notification.Builder buildBaseNotification(Context context, int port, NotificationManager manager) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // Note: IMPORTANCE_LOW so no sound is played to avoid distractions while testing.
+            NotificationChannel channel = new NotificationChannel(NOTIFICATION_CHANNEL_ID,
+                    "ObjectBox Admin", NotificationManager.IMPORTANCE_LOW);
+            // if channel already exists, create call will be ignored
+            manager.createNotificationChannel(channel);
+        }
+
+        Notification.Builder builder;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            builder = new Notification.Builder(context, NOTIFICATION_CHANNEL_ID);
+        } else {
+            builder = new Notification.Builder(context);
+        }
+
+        builder.setContentTitle(context.getString(R.string.objectbox_objectBrowserNotificationTitle))
+                .setContentText(context.getString(R.string.objectbox_objectBrowserNotificationText, port))
+                .setSmallIcon(R.drawable.objectbox_notification);
+
+        return builder;
+    }
+
+    static Intent viewIntent(String url) {
+        Intent viewIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(url));
+        viewIntent.setFlags(FLAG_ACTIVITY_NEW_TASK);
+        return viewIntent;
+    }
+
+    /**
+     * Targeting Android 12 requires to mark PendingIntents explicitly as immutable or mutable.
+     * https://developer.android.com/about/versions/12/behavior-changes-12#pending-intent-mutability
+     */
+    static int buildPendingIntentFlags(int flags) {
+        if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            return flags | PendingIntent.FLAG_IMMUTABLE;
+        } else {
+            return flags;
+        }
+    }
+
+}
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminKeepAliveService.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminKeepAliveService.java
new file mode 100644
index 00000000..1d0f1c78
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminKeepAliveService.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.app.Notification;
+import android.app.Notification.Action.Builder;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.os.IBinder;
+import android.util.Log;
+
+import javax.annotation.Nullable;
+
+/**
+ * Foreground service to keep app alive which displays a notification to view {@link Admin} URL or stop this service.
+ */
+public class AdminKeepAliveService extends Service {
+
+    private static final String ACTION_STOP = "objectBox_keepAliveStop";
+
+    static final String EXTRA_KEY_PORT = "port";
+    static final String EXTRA_KEY_URL = "url";
+    static final String EXTRA_KEY_NOTIFICATION_ID = "notificationId";
+
+    private static final String TAG = AdminKeepAliveService.class.getSimpleName();
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (ACTION_STOP.equals(intent.getAction())) {
+            Log.d(TAG, "Stopping");
+            stopForeground(true);
+            stopSelf();
+            return START_NOT_STICKY;
+        }
+        String url = intent.getStringExtra(EXTRA_KEY_URL);
+        int port = intent.getIntExtra(EXTRA_KEY_PORT, 0);
+        int notificationId = intent.getIntExtra(EXTRA_KEY_NOTIFICATION_ID, 0);
+
+        if (url != null && url.startsWith("http") && port > 0 && notificationId > 0) {
+            Intent stopIntent = new Intent(this, getClass());
+            stopIntent.setAction(ACTION_STOP);
+            PendingIntent stopPendingIntent = PendingIntent.getService(this, 0, stopIntent,
+                    Admin.buildPendingIntentFlags(PendingIntent.FLAG_CANCEL_CURRENT));
+            PendingIntent pendingIntent = PendingIntent.getActivity(this, 0,
+                    Admin.viewIntent(url), Admin.buildPendingIntentFlags(0));
+
+            NotificationManager manager =
+                    (NotificationManager) getSystemService(Context.NOTIFICATION_SERVICE);
+            Notification.Builder builder = Admin.buildBaseNotification(this, port, manager);
+            builder.setContentIntent(pendingIntent);
+            // Actually useless because Foreground notifications cannot be deleted
+            builder.setDeleteIntent(stopPendingIntent);
+            builder.addAction(new Builder(R.drawable.objectbox_stop, "Stop", stopPendingIntent).build());
+
+            startForeground(notificationId, builder.getNotification());
+            Log.d(TAG, "Started");
+            return START_REDELIVER_INTENT; // with START_STICKY would not get intent on restart
+        } else {
+            Log.w(TAG, "Ignoring start command due to incomplete data");
+            return START_NOT_STICKY;
+        }
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminNotificationReceiver.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminNotificationReceiver.java
new file mode 100644
index 00000000..51db3850
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AdminNotificationReceiver.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.util.Log;
+
+/**
+ * Handles actions of the {@link Admin} notification.
+ */
+public class AdminNotificationReceiver extends BroadcastReceiver {
+
+    private static final String TAG = AdminNotificationReceiver.class.getSimpleName();
+    static final String ACTION_KEEP_ALIVE = "io.objectbox.action.KEEP_ALIVE";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        if (!ACTION_KEEP_ALIVE.equals(intent.getAction())) {
+            return;
+        }
+        if (!intent.hasExtra(AdminKeepAliveService.EXTRA_KEY_URL)) {
+            Log.w(TAG, "Ignoring keep alive intent due to incomplete data");
+            return;
+        }
+
+        // start foreground service to keep app process alive
+        Intent serviceIntent = new Intent(context, AdminKeepAliveService.class);
+        serviceIntent.putExtras(intent);
+        if (VERSION.SDK_INT >= VERSION_CODES.O) {
+            context.startForegroundService(serviceIntent);
+        } else {
+            context.startService(serviceIntent);
+        }
+
+        // launch browser
+        String url = intent.getStringExtra(AdminKeepAliveService.EXTRA_KEY_URL);
+        context.startActivity(Admin.viewIntent(url));
+    }
+
+}
diff --git a/objectbox-android/src/adminIncluded/java/io/objectbox/android/AndroidObjectBrowser.java b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AndroidObjectBrowser.java
new file mode 100644
index 00000000..f5651a56
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/java/io/objectbox/android/AndroidObjectBrowser.java
@@ -0,0 +1,92 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.content.Context;
+
+import io.objectbox.BoxStore;
+
+/**
+ * A helper class to start the ObjectBox Admin web app used to browse and gain insights into the database.
+ * <p>
+ * Usage requires manually configuring some ObjectBox dependencies, see the
+ * <a href="https://docs.objectbox.io/data-browser">documentation</a> for more details.
+ *
+ * <pre>
+ * if (BuildConfig.DEBUG) {
+ *     boolean started = new AndroidObjectBrowser(boxStore).start(this);
+ *     Log.i("ObjectBoxAdmin", "Started: " + started);
+ * }
+ * </pre>
+ * After {@link #start} is called a notification is displayed. Tap it to open this Admin URL on the device.
+ * Alternatively, look for a logcat message from Admin to obtain the URL. Use {@code adb forward} to access
+ * the URL on your development machine.
+ * <p>
+ * Tapping the notification starts a foreground service to keep this app running in the background.
+ * Stop this keep-alive service from the notification.
+ * <p>
+ * See the web <a href="https://docs.objectbox.io/data-browser">documentation</a> for details.
+ *
+ * @deprecated Use {@link Admin} instead.
+ */
+@Deprecated
+public class AndroidObjectBrowser extends Admin {
+
+    /**
+     * Creates a helper to control Admin for the given {@code boxStore}.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public AndroidObjectBrowser(BoxStore boxStore) {
+        super(boxStore);
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public int getNotificationId() {
+        return super.getNotificationId();
+    }
+
+    /**
+     * The id passed to {@link android.app.NotificationManager#notify} for the Admin notification.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public void setNotificationId(int notificationId) {
+        super.setNotificationId(notificationId);
+    }
+
+    /**
+     * Starts the ObjectBox Admin HTTP server.
+     * <p>
+     * See the {@link AndroidObjectBrowser class documentation} for details.
+     *
+     * @deprecated Use {@link Admin} instead.
+     */
+    @Deprecated
+    public boolean start(Context context) {
+        return super.start(context);
+    }
+}
diff --git a/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_notification.png
new file mode 100644
index 00000000..84236e32
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_stop.png
new file mode 100644
index 00000000..dfff26ce
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-hdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_notification.png
new file mode 100644
index 00000000..da2b3038
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_stop.png
new file mode 100644
index 00000000..9f6dc9ef
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-mdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_notification.png
new file mode 100644
index 00000000..0719e380
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_stop.png
new file mode 100644
index 00000000..3ad2c9c4
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xhdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_notification.png
new file mode 100644
index 00000000..97af3800
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_stop.png
new file mode 100644
index 00000000..801d3411
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxhdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_notification.png b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_notification.png
new file mode 100644
index 00000000..a6bc5520
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_notification.png differ
diff --git a/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_stop.png b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_stop.png
new file mode 100644
index 00000000..52393366
Binary files /dev/null and b/objectbox-android/src/adminIncluded/res/drawable-xxxhdpi/objectbox_stop.png differ
diff --git a/objectbox-android/src/adminIncluded/res/values/strings.xml b/objectbox-android/src/adminIncluded/res/values/strings.xml
new file mode 100644
index 00000000..d6de685e
--- /dev/null
+++ b/objectbox-android/src/adminIncluded/res/values/strings.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<resources>
+    <string name="objectbox_objectBrowserNotificationTitle">ObjectBox Admin</string>
+    <!-- Text should not be too long, or it is cut off. -->
+    <string name="objectbox_objectBrowserNotificationText">Running on port %1$d. Tap to open and keep app running.</string>
+</resources>
diff --git a/objectbox-android/src/main/AndroidManifest.xml b/objectbox-android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..44cfa242
--- /dev/null
+++ b/objectbox-android/src/main/AndroidManifest.xml
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+
+    <!-- Note that the objectbox-android-objectbrowser AAR ships a different manifest! -->
+
+    <!-- Required for Android library https://developer.android.com/studio/projects/android-library#aar-contents -->
+
+</manifest>
diff --git a/objectbox-android/src/main/java/io/objectbox/android/AndroidScheduler.java b/objectbox-android/src/main/java/io/objectbox/android/AndroidScheduler.java
new file mode 100644
index 00000000..ac2c358c
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/AndroidScheduler.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.os.Handler;
+import android.os.Looper;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+
+import androidx.annotation.NonNull;
+import io.objectbox.reactive.RunWithParam;
+import io.objectbox.reactive.Scheduler;
+
+/**
+ * A Looper-based Scheduler implementation, see {@link #mainThread()} for most common usage.
+ */
+public class AndroidScheduler extends Handler implements Scheduler {
+    private static AndroidScheduler MAIN_THREAD;
+
+    /**
+     * Returns a Scheduler that runs tasks on Android's main thread.
+     */
+    public static synchronized Scheduler mainThread() {
+        if (MAIN_THREAD == null) {
+            MAIN_THREAD = new AndroidScheduler(Looper.getMainLooper());
+        }
+        return MAIN_THREAD;
+    }
+
+    private final Deque<Runner> freeRunners = new ArrayDeque<>();
+
+    /**
+     * If you run your own Looper, you can create a custom Scheduler using it.
+     */
+    public AndroidScheduler(Looper looper) {
+        super(looper);
+    }
+
+    // Note: need to cast to RunWithParam<Object>, not sure how to solve differently.
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> void run(@NonNull RunWithParam<T> runnable, @NonNull T param) {
+        Runner runner;
+        synchronized (freeRunners) {
+            runner = freeRunners.poll();
+        }
+        if (runner == null) {
+            runner = new Runner();
+        }
+        runner.runWithParam = (RunWithParam<Object>) runnable;
+        runner.param = param;
+        post(runner);
+    }
+
+    class Runner implements Runnable {
+        RunWithParam<Object> runWithParam;
+        Object param;
+
+        @Override
+        public void run() {
+            runWithParam.run(param);
+            runWithParam = null;
+            param = null;
+            synchronized (freeRunners) {
+                if (freeRunners.size() < 20) {
+                    freeRunners.add(this);
+                }
+            }
+        }
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxDataSource.java b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxDataSource.java
new file mode 100644
index 00000000..9a62561c
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxDataSource.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2018 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import java.util.Collections;
+import java.util.List;
+
+import androidx.annotation.NonNull;
+import androidx.paging.DataSource;
+import androidx.paging.PositionalDataSource;
+import io.objectbox.query.Query;
+import io.objectbox.reactive.DataObserver;
+
+/**
+ * A {@link PositionalDataSource} that loads entities based on an ObjectBox {@link Query} using
+ * offset and limit to implement paging support. The data source is invalidated if the query results
+ * change.
+ */
+public class ObjectBoxDataSource<T> extends PositionalDataSource<T> {
+
+    private final Query<T> query;
+    @SuppressWarnings("FieldCanBeLocal")
+    private final DataObserver<List<T>> observer;
+
+    public static class Factory<Item> extends DataSource.Factory<Integer, Item> {
+
+        private final Query<Item> query;
+
+        public Factory(Query<Item> query) {
+            this.query = query;
+        }
+
+        @NonNull
+        @Override
+        public DataSource<Integer, Item> create() {
+            return new ObjectBoxDataSource<>(query);
+        }
+    }
+
+    public ObjectBoxDataSource(Query<T> query) {
+        this.query = query;
+        this.observer = data -> {
+            // if data changes invalidate this data source and create a new one
+            invalidate();
+        };
+        // observer will be automatically removed once GC'ed
+        query.subscribe().onlyChanges().weak().observer(observer);
+    }
+
+    @Override
+    public void loadInitial(@NonNull LoadInitialParams params, @NonNull LoadInitialCallback<T> callback) {
+        // note: limiting to int should be fine for Android apps
+        int totalCount = (int) query.count();
+        if (totalCount == 0) {
+            callback.onResult(Collections.emptyList(), 0, 0);
+            return;
+        }
+
+        int position = computeInitialLoadPosition(params, totalCount);
+        int loadSize = computeInitialLoadSize(params, position, totalCount);
+
+        List<T> list = loadRange(position, loadSize);
+        if (list.size() == loadSize) {
+            callback.onResult(list, position, totalCount);
+        } else {
+            invalidate(); // size doesn't match request - DB modified between count and load
+        }
+    }
+
+    @Override
+    public void loadRange(@NonNull LoadRangeParams params, @NonNull LoadRangeCallback<T> callback) {
+        callback.onResult(loadRange(params.startPosition, params.loadSize));
+    }
+
+    private List<T> loadRange(int startPosition, int loadCount) {
+        // note: find interprets loadCount 0 as no limit
+        return query.find(startPosition, loadCount);
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxLiveData.java b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxLiveData.java
new file mode 100644
index 00000000..3a130aa3
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/ObjectBoxLiveData.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2017 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import java.util.List;
+
+import androidx.lifecycle.LiveData;
+import io.objectbox.query.Query;
+import io.objectbox.reactive.DataObserver;
+import io.objectbox.reactive.DataSubscription;
+
+/**
+ * A {@link LiveData} which allows to observe changes to results of the given query.
+ */
+public class ObjectBoxLiveData<T> extends LiveData<List<T>> {
+    private final Query<T> query;
+    private DataSubscription subscription;
+
+    private final DataObserver<List<T>> listener = this::postValue;
+
+    public ObjectBoxLiveData(Query<T> query) {
+        this.query = query;
+    }
+
+    @Override
+    protected void onActive() {
+        // called when the LiveData object has an active observer
+        if (subscription == null) {
+            subscription = query.subscribe().observer(listener);
+        }
+    }
+
+    @Override
+    protected void onInactive() {
+        // called when the LiveData object doesn't have any active observers
+        if (!hasObservers()) {
+            subscription.cancel();
+            subscription = null;
+        }
+    }
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidConnectivityMonitor.java b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidConnectivityMonitor.java
new file mode 100644
index 00000000..0c79ad27
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidConnectivityMonitor.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2020 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android.internal;
+
+import android.annotation.SuppressLint;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.NetworkInfo;
+
+import androidx.annotation.Nullable;
+import io.objectbox.sync.ConnectivityMonitor;
+
+/**
+ * A {@link ConnectivityMonitor} that registers a {@link AndroidNetworkStateReceiver}
+ * while it has an observer set.
+ */
+class AndroidConnectivityMonitor extends ConnectivityMonitor {
+
+    private final Context context;
+
+    @Nullable
+    private AndroidNetworkStateReceiver receiver;
+
+    AndroidConnectivityMonitor(Context context) {
+        this.context = context.getApplicationContext();
+    }
+
+    @Override
+    public void onObserverSet() {
+        AndroidNetworkStateReceiver receiver = new AndroidNetworkStateReceiver();
+        IntentFilter filter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
+        context.registerReceiver(receiver, filter);
+        this.receiver = receiver;
+    }
+
+    @Override
+    public void onObserverRemoved() {
+        AndroidNetworkStateReceiver receiverToRemove = this.receiver;
+        this.receiver = null;
+        if (receiverToRemove != null) {
+            context.unregisterReceiver(receiverToRemove);
+        }
+    }
+
+    /**
+     * Notifies the given monitor on the main thread if a network connection is available
+     * after a {@link ConnectivityManager#CONNECTIVITY_ACTION} was broadcast.
+     */
+    class AndroidNetworkStateReceiver extends BroadcastReceiver {
+
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (!ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
+                return; // Ignore unexpected broadcasts.
+            }
+
+            ConnectivityManager cm =
+                    (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+
+            @SuppressLint("MissingPermission") // Permission checked before registering.
+                    NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
+            boolean isConnected = activeNetwork != null && activeNetwork.isConnected();
+
+            if (isConnected) {
+                notifyConnectionAvailable();
+            }
+        }
+
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidPlatform.java b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidPlatform.java
new file mode 100644
index 00000000..be14f987
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/internal/AndroidPlatform.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2020 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android.internal;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.pm.PackageManager;
+import android.os.Process;
+
+import androidx.annotation.Nullable;
+import io.objectbox.sync.ConnectivityMonitor;
+import io.objectbox.sync.internal.Platform;
+
+/**
+ * Provides Android-specific features.
+ * <p>
+ * Requires the {@link Manifest.permission#ACCESS_NETWORK_STATE ACCESS_NETWORK_STATE} permission.
+ */
+public class AndroidPlatform extends Platform {
+
+    public static AndroidPlatform create(Context context) {
+        return new AndroidPlatform(context.getApplicationContext());
+    }
+
+    private final ConnectivityMonitor connectivityMonitor;
+
+    private AndroidPlatform(Context context) {
+        // AndroidConnectivityMonitor requires the ACCESS_NETWORK_STATE permission.
+        // Most apps have it, so just do not provide a connectivity monitor if not.
+        if (context.checkPermission(Manifest.permission.ACCESS_NETWORK_STATE,
+                Process.myPid(), Process.myUid()) == PackageManager.PERMISSION_GRANTED) {
+            connectivityMonitor = new AndroidConnectivityMonitor(context);
+        } else {
+            connectivityMonitor = null;
+        }
+    }
+
+    @Override
+    @Nullable
+    public ConnectivityMonitor getConnectivityMonitor() {
+        return connectivityMonitor;
+    }
+
+}
diff --git a/objectbox-android/src/main/java/io/objectbox/android/sync/ObjectBoxForegroundService.java b/objectbox-android/src/main/java/io/objectbox/android/sync/ObjectBoxForegroundService.java
new file mode 100644
index 00000000..830ca4dc
--- /dev/null
+++ b/objectbox-android/src/main/java/io/objectbox/android/sync/ObjectBoxForegroundService.java
@@ -0,0 +1,102 @@
+/*
+ * Copyright 2021 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android.sync;
+
+import android.Manifest;
+import android.app.Notification;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.IBinder;
+import android.os.Process;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+/**
+ * A no-op foreground {@link Service} to make it less likely an app is killed by the system.
+ * Use {@link #start} and {@link #stop} to control the service.
+ */
+public class ObjectBoxForegroundService extends Service {
+
+    public static final String ACTION_START = "obx_foreground_start";
+    public static final String ACTION_STOP = "obx_foreground_stop";
+    private static final String TAG = "OBX_FOREGROUND";
+
+    private static int notificationId;
+    @Nullable
+    private static Notification notification;
+
+    public static void start(Context context, int notificationId, Notification notification) {
+        // Require FOREGROUND_SERVICE permission on Android 9 (API level 28)
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P
+                && context.getApplicationInfo().targetSdkVersion >= Build.VERSION_CODES.P) {
+            // SecurityException if no FOREGROUND_SERVICE permission
+            context.enforcePermission(Manifest.permission.FOREGROUND_SERVICE, Process.myPid(), Process.myUid(), null);
+        }
+
+        ObjectBoxForegroundService.notificationId = notificationId;
+        ObjectBoxForegroundService.notification = notification;
+        Intent intent = new Intent(context, ObjectBoxForegroundService.class);
+        intent.setAction(ACTION_START);
+        startServiceIntent(context, intent);
+    }
+
+    public static void stop(Context context) {
+        Intent intent = new Intent(context, ObjectBoxForegroundService.class);
+        intent.setAction(ACTION_STOP);
+        startServiceIntent(context, intent);
+    }
+
+    private static void startServiceIntent(Context context, Intent intent) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            context.startForegroundService(intent);
+        } else {
+            context.startService(intent);
+        }
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (ACTION_STOP.equals(intent.getAction())) {
+            Log.d(TAG, "Stopping...");
+            stopForeground(true);
+            stopSelf();
+            return START_NOT_STICKY;
+        } else if (ACTION_START.equals(intent.getAction())) {
+            Log.d(TAG, "Starting...");
+            int notificationId = ObjectBoxForegroundService.notificationId;
+            Notification notification = ObjectBoxForegroundService.notification;
+            if (notificationId == 0 || notification == null) {
+                throw new IllegalArgumentException("No arguments given: notificationId or notification not set.");
+            }
+            startForeground(notificationId, notification);
+            // Note: with START_STICKY would not get intent on restart.
+            return START_REDELIVER_INTENT;
+        } else {
+            Log.w(TAG, "Ignoring start command: no action specified.");
+            return START_NOT_STICKY;
+        }
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}
diff --git a/objectbox-android/src/test/java/io/objectbox/android/AndroidPlatformTest.java b/objectbox-android/src/test/java/io/objectbox/android/AndroidPlatformTest.java
new file mode 100644
index 00000000..710afd08
--- /dev/null
+++ b/objectbox-android/src/test/java/io/objectbox/android/AndroidPlatformTest.java
@@ -0,0 +1,45 @@
+/*
+ * Copyright 2020 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.android;
+
+import android.Manifest;
+
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.rule.GrantPermissionRule;
+import io.objectbox.android.internal.AndroidPlatform;
+
+import static org.junit.Assert.assertNotNull;
+
+@RunWith(AndroidJUnit4.class)
+public class AndroidPlatformTest {
+
+    @Rule
+    public GrantPermissionRule mRuntimePermissionRule = GrantPermissionRule
+            .grant(Manifest.permission.ACCESS_NETWORK_STATE);
+
+    @Test
+    public void builds() {
+        AndroidPlatform platform = AndroidPlatform.create(ApplicationProvider.getApplicationContext());
+        assertNotNull(platform);
+        assertNotNull(platform.getConnectivityMonitor());
+    }
+}
diff --git a/objectbox-java-api/build.gradle b/objectbox-java-api/build.gradle
deleted file mode 100644
index 1da50b0c..00000000
--- a/objectbox-java-api/build.gradle
+++ /dev/null
@@ -1,40 +0,0 @@
-apply plugin: 'java-library'
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    archiveClassifier.set('javadoc')
-    from 'build/docs/javadoc'
-}
-
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    archiveClassifier.set('sources')
-}
-
-artifacts {
-    // java plugin adds jar.
-    archives javadocJar
-    archives sourcesJar
-}
-
-uploadArchives {
-    repositories {
-        mavenDeployer {
-            // Basic definitions are defined in root project
-            pom.project {
-                name 'ObjectBox API'
-                description 'ObjectBox is a fast NoSQL database for Objects'
-
-                licenses {
-                    license {
-                        name 'The Apache Software License, Version 2.0'
-                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-                        distribution 'repo'
-                    }
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/objectbox-java-api/build.gradle.kts b/objectbox-java-api/build.gradle.kts
new file mode 100644
index 00000000..e7c48d62
--- /dev/null
+++ b/objectbox-java-api/build.gradle.kts
@@ -0,0 +1,45 @@
+plugins {
+    id("java-library")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    dependsOn(tasks.javadoc)
+    archiveClassifier.set("javadoc")
+    from("build/docs/javadoc")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    from(sourceSets.main.get().allSource)
+    archiveClassifier.set("sources")
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxJavaApi = "objectboxJavaApi"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxJavaApi) {
+            artifactId = "objectbox-java-api"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            artifact(javadocJar)
+
+            pom {
+                name.set("ObjectBox Java Annotations")
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxJavaApi])
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java
index 2000ac4a..352d2237 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Backlink.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java
index b00cd2e8..e19f851d 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/BaseEntity.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2017-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 import java.lang.annotation.ElementType;
@@ -6,8 +22,9 @@
 import java.lang.annotation.Target;
 
 /**
- * Annotation for an entity base class.
- * ObjectBox will include properties of an entity super class marked with this annotation.
+ * Marks a class as an ObjectBox Entity super class.
+ * ObjectBox will store properties of this class as part of an Entity that inherits from this class.
+ * See <a href="https://docs.objectbox.io/advanced/entity-inheritance">the Entity Inheritance documentation</a> for details.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.TYPE)
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java
new file mode 100644
index 00000000..38632aca
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ConflictStrategy.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2018-2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+/**
+ * Used with {@link Unique} to specify the conflict resolution strategy.
+ */
+public enum ConflictStrategy {
+
+    /**
+     * Throws UniqueViolationException if any property violates a {@link Unique} constraint.
+     */
+    FAIL,
+    /**
+     * Any conflicting objects are deleted before the object is inserted.
+     */
+    REPLACE
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java
index c85844ee..c7d256b6 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Convert.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,25 +16,29 @@
 
 package io.objectbox.annotation;
 
-import io.objectbox.converter.PropertyConverter;
-
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
+import io.objectbox.converter.PropertyConverter;
+
 /**
- * Specifies {@link PropertyConverter} for the field to support custom types
+ * Supplies a {@link PropertyConverter converter} to store custom Property types as a supported {@link #dbType()}.
+ * See the <a href="https://docs.objectbox.io/advanced/custom-types">Custom Types documentation</a> for details.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.FIELD)
 public @interface Convert {
-    /** Converter class */
+    /**
+     * The converter class that ObjectBox should use. See {@link PropertyConverter} for implementation guidelines.
+     */
     Class<? extends PropertyConverter> converter();
 
     /**
-     * Class of the DB type the Java property is converted to/from.
-     * This is limited to all java classes which are supported natively by ObjectBox.
+     * The Property type the Java field value is converted to/from.
+     * See the <a href="https://docs.objectbox.io/advanced/custom-types">Custom Types documentation</a> for a list
+     * of supported types.
      */
     Class dbType();
 }
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java
new file mode 100644
index 00000000..8b38596b
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/DatabaseType.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2019 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+/**
+ * Use with {@link Type @Type} to override how a property value is stored and interpreted in the database.
+ */
+public enum DatabaseType {
+
+    /**
+     * Use with 64-bit long properties to store them as high precision time
+     * representing nanoseconds since 1970-01-01 (unix epoch).
+     * <p>
+     * By default, a 64-bit long value is interpreted as time in milliseconds (a Date).
+     */
+    DateNano
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java
index 1b50f0e5..a6e0300b 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/DefaultValue.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.annotation;
 
 import java.lang.annotation.ElementType;
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java
index eeda7ff6..64518500 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Entity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,8 +22,8 @@
 import java.lang.annotation.Target;
 
 /**
- * Annotation for entities
- * ObjectBox only persist objects of classes which are marked with this annotation
+ * Marks a class as an ObjectBox Entity.
+ * Allows to obtain a Box for this Entity from BoxStore to persist Objects of this class.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.TYPE)
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Temporary.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalName.java
similarity index 65%
rename from objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Temporary.java
rename to objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalName.java
index 2df2eda9..7b196e78 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Temporary.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalName.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,19 +14,23 @@
  * limitations under the License.
  */
 
-package io.objectbox.annotation.apihint;
+package io.objectbox.annotation;
 
-import java.lang.annotation.Documented;
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 
 /**
- * APIs annotated with @Temporary will most likely be replaced with another API in a future release.
+ * Sets the name of an {@link Entity @Entity}, a property or a ToMany in an external system (like another database).
  */
 @Retention(RetentionPolicy.CLASS)
-@Target({ElementType.ANNOTATION_TYPE, ElementType.CONSTRUCTOR, ElementType.FIELD, ElementType.METHOD, ElementType.TYPE})
-@Documented
-public @interface Temporary {
+@Target({ElementType.TYPE, ElementType.FIELD})
+public @interface ExternalName {
+
+    /**
+     * The name assigned to the annotated element in the external system.
+     */
+    String value();
+
 }
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalPropertyType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalPropertyType.java
new file mode 100644
index 00000000..29e0296c
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalPropertyType.java
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+
+/**
+ * A property type of an external system (e.g. another database) that has no default mapping to an ObjectBox type.
+ * <p>
+ * Use with {@link ExternalType @ExternalType}.
+ */
+public enum ExternalPropertyType {
+
+    /**
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation, little endian (16 bytes)
+     */
+    INT_128,
+    /**
+     * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+     * <p>
+     * ObjectBox uses the UUIDv7 scheme (timestamp + random) to create new UUIDs. UUIDv7 is a good choice for database
+     * keys as it's mostly sequential and encodes a timestamp. However, if keys are used externally, consider
+     * {@link #UUID_V4} for better privacy by not exposing any time information.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (16 bytes)
+     */
+    UUID,
+    /**
+     * IEEE 754 decimal128 type, e.g. supported by MongoDB.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (16 bytes)
+     */
+    DECIMAL_128,
+    /**
+     * UUID represented as a string of 36 characters, e.g. "019571b4-80e3-7516-a5c1-5f1053d23fff".
+     * <p>
+     * For efficient storage, consider the {@link #UUID} type instead, which occupies only 16 bytes (20 bytes less).
+     * This type may still be a convenient alternative as the string type is widely supported and more human-readable.
+     * In accordance to standards, new UUIDs generated by ObjectBox use lowercase hexadecimal digits.
+     * <p>
+     * Representing type: String
+     */
+    UUID_STRING,
+    /**
+     * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+     * <p>
+     * ObjectBox uses the UUIDv4 scheme (completely random) to create new UUIDs.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (16 bytes)
+     */
+    UUID_V4,
+    /**
+     * Like {@link #UUID_STRING}, but using the UUIDv4 scheme (completely random) to create new UUID.
+     * <p>
+     * Representing type: String
+     */
+    UUID_V4_STRING,
+    /**
+     * A key/value map; e.g. corresponds to a JSON object or a MongoDB document (although not keeping the key order).
+     * Unlike the Flex type, this must contain a map value (e.g. not a vector or a scalar).
+     * <p>
+     * Representing type: Flex
+     * <p>
+     * Encoding: Flex
+     */
+    FLEX_MAP,
+    /**
+     * A vector (aka list or array) of flexible elements; e.g. corresponds to a JSON array or a MongoDB array. Unlike
+     * the Flex type, this must contain a vector value (e.g. not a map or a scalar).
+     * <p>
+     * Representing type: Flex
+     * <p>
+     * Encoding: Flex
+     */
+    FLEX_VECTOR,
+    /**
+     * Placeholder (not yet used) for a JSON document.
+     * <p>
+     * Representing type: String
+     */
+    JSON,
+    /**
+     * Placeholder (not yet used) for a BSON document.
+     * <p>
+     * Representing type: ByteVector
+     */
+    BSON,
+    /**
+     * JavaScript source code.
+     * <p>
+     * Representing type: String
+     */
+    JAVASCRIPT,
+    /**
+     * A JSON string that is converted to a native "complex" representation in the external system.
+     * <p>
+     * For example in MongoDB, embedded/nested documents are converted to a JSON string in ObjectBox and vice versa.
+     * This allows a quick and simple way to work with non-normalized data from MongoDB in ObjectBox. Alternatively, you
+     * can use {@link #FLEX_MAP} and {@link #FLEX_VECTOR} to map to language primitives (e.g. maps with string keys; not
+     * supported by all ObjectBox languages yet).
+     * <p>
+     * For MongoDB, (nested) documents and arrays are supported.
+     * <p>
+     * Note that this is very close to the internal representation, e.g. the key order is preserved (unlike Flex).
+     * <p>
+     * Representing type: String
+     */
+    JSON_TO_NATIVE,
+    /**
+     * A vector (array) of Int128 values.
+     */
+    INT_128_VECTOR,
+    /**
+     * A vector (array) of Uuid values.
+     */
+    UUID_VECTOR,
+    /**
+     * The 12-byte ObjectId type in MongoDB.
+     * <p>
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 1:1 binary representation (12 bytes)
+     */
+    MONGO_ID,
+    /**
+     * A vector (array) of MongoId values.
+     */
+    MONGO_ID_VECTOR,
+    /**
+     * Representing type: Long
+     * <p>
+     * Encoding: Two unsigned 32-bit integers merged into a 64-bit integer.
+     */
+    MONGO_TIMESTAMP,
+    /**
+     * Representing type: ByteVector
+     * <p>
+     * Encoding: 3 zero bytes (reserved, functions as padding), fourth byte is the sub-type, followed by the binary
+     * data.
+     */
+    MONGO_BINARY,
+    /**
+     * Representing type: string vector with 2 elements (index 0: pattern, index 1: options)
+     * <p>
+     * Encoding: 1:1 string representation
+     */
+    MONGO_REGEX
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalType.java
new file mode 100644
index 00000000..d72d27a4
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/ExternalType.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Sets the type of a property or the type of object IDs of a ToMany in an external system (like another database).
+ * <p>
+ * This is useful if there is no default mapping of the ObjectBox type to the type in the external system.
+ * <p>
+ * Carefully look at the documentation of the external type to ensure it is compatible with the ObjectBox type.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.FIELD})
+public @interface ExternalType {
+
+    ExternalPropertyType value();
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswFlags.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswFlags.java
new file mode 100644
index 00000000..27073a6b
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswFlags.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+/**
+ * Flags as a part of the {@link HnswIndex} configuration.
+ */
+public @interface HnswFlags {
+
+    /**
+     * Enables debug logs.
+     */
+    boolean debugLogs() default false;
+
+    /**
+     * Enables "high volume" debug logs, e.g. individual gets/puts.
+     */
+    boolean debugLogsDetailed() default false;
+
+    /**
+     * Padding for SIMD is enabled by default, which uses more memory but may be faster. This flag turns it off.
+     */
+    boolean vectorCacheSimdPaddingOff() default false;
+
+    /**
+     * If the speed of removing nodes becomes a concern in your use case, you can speed it up by setting this flag. By
+     * default, repairing the graph after node removals creates more connections to improve the graph's quality. The
+     * extra costs for this are relatively low (e.g. vs. regular indexing), and thus the default is recommended.
+     */
+    boolean reparationLimitCandidates() default false;
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswIndex.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswIndex.java
new file mode 100644
index 00000000..3ced6191
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/HnswIndex.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Parameters to configure HNSW-based approximate nearest neighbor (ANN) search. Some of the parameters can influence
+ * index construction and searching. Changing these values causes re-indexing, which can take a while due to the complex
+ * nature of HNSW.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface HnswIndex {
+
+    /**
+     * Dimensions of vectors; vector data with fewer dimensions are ignored. Vectors with more dimensions than specified
+     * here are only evaluated up to the given dimension value. Changing this value causes re-indexing.
+     */
+    long dimensions();
+
+    /**
+     * Aka "M": the max number of connections per node (default: 30). Higher numbers increase the graph connectivity,
+     * which can lead to more accurate search results. However, higher numbers also increase the indexing time and
+     * resource usage. Try e.g. 16 for faster but less accurate results, or 64 for more accurate results. Changing this
+     * value causes re-indexing.
+     */
+    long neighborsPerNode() default 0;
+
+    /**
+     * Aka "efConstruction": the number of neighbor searched for while indexing (default: 100). The higher the value,
+     * the more accurate the search, but the longer the indexing. If indexing time is not a major concern, a value of at
+     * least 200 is recommended to improve search quality. Changing this value causes re-indexing.
+     */
+    long indexingSearchCount() default 0;
+
+    /**
+     * See {@link HnswFlags}.
+     */
+    HnswFlags flags() default @HnswFlags;
+
+    /**
+     * The distance type used for the HNSW index. Changing this value causes re-indexing.
+     */
+    VectorDistanceType distanceType() default VectorDistanceType.DEFAULT;
+
+    /**
+     * When repairing the graph after a node was removed, this gives the probability of adding backlinks to the repaired
+     * neighbors. The default is 1.0 (aka "always") as this should be worth a bit of extra costs as it improves the
+     * graph's quality.
+     */
+    float reparationBacklinkProbability() default 1.0F;
+
+    /**
+     * A non-binding hint at the maximum size of the vector cache in KB (default: 2097152 or 2 GB/GiB). The actual size
+     * max cache size may be altered according to device and/or runtime settings. The vector cache is used to store
+     * vectors in memory to speed up search and indexing.
+     * <p>
+     * Note 1: cache chunks are allocated only on demand, when they are actually used. Thus, smaller datasets will use
+     * less memory.
+     * <p>
+     * Note 2: the cache is for one specific HNSW index; e.g. each index has its own cache.
+     * <p>
+     * Note 3: the memory consumption can temporarily exceed the cache size, e.g. for large changes, it can double due
+     * to multi-version transactions.
+     */
+    long vectorCacheHintSizeKB() default 0;
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java
index c07579f8..9656d733 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Id.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java
new file mode 100644
index 00000000..29a80ec9
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/IdCompanion.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a property as a companion to an @Id property. There can only be one companion property.
+ * <p>
+ * By defining an @Id companion property, the entity type uses a special ID encoding scheme involving this property
+ * in addition to the ID.
+ * <p>
+ * For Time Series IDs, a companion property of type Date or DateNano represents the exact timestamp.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface IdCompanion {
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java
index 123d239a..799c9e51 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Index.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,10 +25,11 @@
  * Specifies that the property should be indexed.
  * <p>
  * It is highly recommended to index properties that are used in a query to improve query performance.
+ * When building a query, make sure to use case sensitive String conditions to utilize the index.
  * <p>
  * To fine tune indexing of a property you can override the default index {@link #type()}.
  * <p>
- * Note: indexes are currently not supported for byte array, float or double properties.
+ * Note: indexes are currently not supported for string array, byte array, float or double properties.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.FIELD)
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java
index 33217349..998a8031 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/IndexType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java
index 692dcda3..151fc465 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/NameInDb.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java
index 4e6f2681..c185cde2 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/NotNull.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java
index 5ec7d2f0..380eb07a 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/OrderBy.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java
new file mode 100644
index 00000000..9a9e6a4a
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Sync.java
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Enables sync for an {@link Entity} class.
+ * <p>
+ * Note that currently sync can not be enabled or disabled for existing entities.
+ * Also synced entities can not have relations to non-synced entities.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.TYPE)
+public @interface Sync {
+
+    /**
+     * Set to {@code true} to enable shared global IDs for a {@link Sync}-enabled {@link Entity} class.
+     * <p>
+     * By default each Sync client has its own local {@link Id ID} space for Objects.
+     * IDs are mapped to global IDs when syncing behind the scenes. Turn this on
+     * to treat Object IDs as global and turn of ID mapping. The ID of an Object will
+     * then be the same on all clients.
+     * <p>
+     * When using this, it is recommended to use {@link Id#assignable() assignable IDs}
+     * to turn off automatically assigned IDs. Without special care, two Sync clients are
+     * likely to overwrite each others Objects if IDs are assigned automatically.
+     */
+    boolean sharedGlobalIds() default false;
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java
new file mode 100644
index 00000000..d51684ae
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncClock.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@code long} (64-bit integer) field of a {@link Sync}-enabled {@link Entity} class as the sync clock, a
+ * "hybrid logical clock" to resolve Sync conflicts.
+ * <p>
+ * These clock values allow "last write wins" conflict resolution.
+ * <p>
+ * There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.
+ * <p>
+ * For new objects, initialize the property value to {@code 0} to reserve "a slot" in the object data. ObjectBox Sync
+ * will update this property automatically on put operations.
+ * <p>
+ * As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface SyncClock {
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java
new file mode 100644
index 00000000..472893c9
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/SyncPrecedence.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a {@code long} (64-bit integer) field of a {@link Sync}-enabled {@link Entity} class as the "sync precedence"
+ * to customize Sync conflict resolution.
+ * <p>
+ * Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins". Defining and
+ * assigning precedence values are completely in the hands of the developer (the ObjectBox user).
+ * <p>
+ * There can be only one sync precedence per sync entity type.
+ * <p>
+ * Typically, it is combined with a {@link SyncClock}, with the latter being the tie-breaker for equal precedence
+ * values.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface SyncPrecedence {
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java
index d18859ae..9b96f855 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/TargetIdProperty.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,8 +22,27 @@
 import java.lang.annotation.Target;
 
 /**
- * Defines the property serving as the target ID of a ToOne.
- * This allows exposing an explicit property, which may be convenient for other parsers/serializers (e.g. JSON).
+ * For a ToOne, changes the name of its associated target ID (or "relation") property.
+ * <p>
+ * <pre>{@code
+ * @Entity
+ * public class Order {
+ *     // Change from default "customerId" to "customerRef"
+ *     @TargetIdProperty("customerRef")
+ *     ToOne<Customer> customer;
+ *     // Optional: expose target ID property (using changed name)
+ *     long customerRef;
+ * }
+ * }</pre>
+ * <p>
+ * A target ID property is implicitly created (so without defining it in the {@link Entity @Entity} class) for each
+ * ToOne and stores the ID of the referenced target object. By default, it's named like the ToOne field plus the suffix
+ * "Id" (for example {@code customerId}).
+ * <p>
+ * Like in the example above, it's still possible to expose the target ID property as an actual field (useful for other
+ * parsers or serializers, like for JSON). But make sure to use the changed name for the field.
+ * <p>
+ * See the <a href="https://docs.objectbox.io/relations">relations documentation</a> for details.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target({ElementType.FIELD, ElementType.TYPE})
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java
index 679d92dc..c4f4c9b4 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Transient.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java
new file mode 100644
index 00000000..0656b42c
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Type.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2019 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Use on a property to override how its value is stored and interpreted in the database.
+ * <p>
+ * For example to change a long to be interpreted as nanoseconds instead of milliseconds:
+ * <pre>
+ * &#064;Type(DatabaseType.DateNano)
+ * public long timeInNanos;
+ * </pre>
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.FIELD})
+public @interface Type {
+
+    DatabaseType value();
+
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java
index 94f1b2f6..4085c8bf 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Uid.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java
index a7963feb..25394aab 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unique.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,12 +24,19 @@
 /**
  * Enforces that the value of a property is unique among all objects in a box before an object can be put.
  * <p>
- * Trying to put an object with offending values will result in a UniqueViolationException.
+ * Trying to put an object with offending values will result in a UniqueViolationException (see {@link ConflictStrategy#FAIL}).
+ * Set {@link #onConflict()} to change this strategy.
  * <p>
- * Unique properties are based on an {@link Index @Index}, so the same restrictions apply.
+ * Note: Unique properties are based on an {@link Index @Index}, so the same restrictions apply.
  * It is supported to explicitly add the {@link Index @Index} annotation to configure the index.
  */
 @Retention(RetentionPolicy.CLASS)
 @Target(ElementType.FIELD)
 public @interface Unique {
+
+    /**
+     * The strategy to use when a conflict is detected when an object is put.
+     */
+    ConflictStrategy onConflict() default ConflictStrategy.FAIL;
+
 }
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java
new file mode 100644
index 00000000..7fd47511
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/Unsigned.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2019 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates that values of an integer property (e.g. int and long in Java)
+ * should be treated as unsigned when doing queries or creating indexes.
+ * <p>
+ * For example consider a set of integers sorted by the default order: [-2, -1, 0, 1, 2].
+ * If all values are treated as unsigned, the order would be [0, 1, 2, -2, -1] instead.
+ */
+@Retention(RetentionPolicy.CLASS)
+@Target(ElementType.FIELD)
+public @interface Unsigned {
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/VectorDistanceType.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/VectorDistanceType.java
new file mode 100644
index 00000000..84682eb8
--- /dev/null
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/VectorDistanceType.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2024-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.annotation;
+
+/**
+ * The vector distance algorithm used by an {@link HnswIndex} (vector search).
+ */
+public enum VectorDistanceType {
+
+    /**
+     * The default; currently {@link #EUCLIDEAN}.
+     */
+    DEFAULT,
+
+    /**
+     * Typically "Euclidean squared" internally.
+     */
+    EUCLIDEAN,
+
+    /**
+     * Cosine similarity compares two vectors irrespective of their magnitude (compares the angle of two vectors).
+     * <p>
+     * Often used for document or semantic similarity.
+     * <p>
+     * Value range: 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+     */
+    COSINE,
+
+    /**
+     * For normalized vectors (vector length == 1.0), the dot product is equivalent to the cosine similarity.
+     * <p>
+     * Because of this, the dot product is often preferred as it performs better.
+     * <p>
+     * Value range (normalized vectors): 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+     */
+    DOT_PRODUCT,
+
+    /**
+     * For geospatial coordinates, more specifically latitude and longitude pairs.
+     * <p>
+     * Note, the vector dimension should be 2, with the latitude being the first element and longitude the second.
+     * If the vector has more than 2 dimensions, only the first 2 dimensions are used.
+     * If the vector has fewer than 2 dimensions, the distance is always zero.
+     * <p>
+     * Internally, this uses haversine distance.
+     * <p>
+     * Value range: 0 km - 6371 * π km (approx. 20015.09 km; half the Earth's circumference)
+     */
+    GEO,
+
+    /**
+     * A custom dot product similarity measure that does not require the vectors to be normalized.
+     * <p>
+     * Note: this is no replacement for cosine similarity (like DotProduct for normalized vectors is). The non-linear
+     * conversion provides a high precision over the entire float range (for the raw dot product). The higher the dot
+     * product, the lower the distance is (the nearer the vectors are). The more negative the dot product, the higher
+     * the distance is (the farther the vectors are).
+     * <p>
+     * Value range: 0.0 - 2.0 (nonlinear; 0.0: nearest, 1.0: orthogonal, 2.0: farthest)
+     */
+    DOT_PRODUCT_NON_NORMALIZED
+}
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java
index eed18b4f..b7966aea 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Beta.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java
index bf541cfb..6136adee 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Experimental.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java
index 783e0168..e1a61883 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/Internal.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java
index 6bcafc47..d4fa34ea 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/apihint/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java b/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java
index 65c31fb1..0fd5d42f 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/annotation/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,9 @@
 
 /**
  * Annotations to mark a class as an {@link io.objectbox.annotation.Entity @Entity},
- * to specify the {@link io.objectbox.annotation.Id @Id} property,
+ * to specify the {@link io.objectbox.annotation.Id @Id} Property,
  * to create an {@link io.objectbox.annotation.Index @Index} or
- * a {@link io.objectbox.annotation.Transient @Transient} property.
+ * a {@link io.objectbox.annotation.Transient @Transient} Property.
  * <p>
  * For more details look at the documentation of individual classes and
  * <a href="https://docs.objectbox.io/entity-annotations">docs.objectbox.io/entity-annotations</a>.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java b/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java
index 6d65717f..44be7bf7 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/converter/PropertyConverter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java b/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java
index 2c11b294..5a066a67 100644
--- a/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java
+++ b/objectbox-java-api/src/main/java/io/objectbox/converter/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 /**
  * For use with {@link io.objectbox.annotation.Convert @Convert}: {@link io.objectbox.converter.PropertyConverter}
- * to convert custom property types.
+ * to convert custom Property types.
  * <p>
  * For more details look at the documentation of individual classes and
  * <a href="https://docs.objectbox.io/advanced/custom-types">docs.objectbox.io/advanced/custom-types</a>.
diff --git a/objectbox-java/build.gradle b/objectbox-java/build.gradle
deleted file mode 100644
index c93e7fd3..00000000
--- a/objectbox-java/build.gradle
+++ /dev/null
@@ -1,137 +0,0 @@
-apply plugin: 'java-library'
-apply plugin: "com.github.spotbugs"
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-dependencies {
-    api project(':objectbox-java-api')
-    implementation 'org.greenrobot:essentials:3.0.0-RC1'
-    implementation 'com.google.flatbuffers:flatbuffers-java:1.12.0'
-    api 'com.google.code.findbugs:jsr305:3.0.2'
-}
-
-spotbugs {
-    ignoreFailures = true
-}
-
-javadoc {
-    // Hide internal API from javadoc artifact.
-    exclude("**/io/objectbox/Cursor.java")
-    exclude("**/io/objectbox/KeyValueCursor.java")
-    exclude("**/io/objectbox/ModelBuilder.java")
-    exclude("**/io/objectbox/Properties.java")
-    exclude("**/io/objectbox/Transaction.java")
-    exclude("**/io/objectbox/model/**")
-    exclude("**/io/objectbox/ideasonly/**")
-    exclude("**/io/objectbox/internal/**")
-    exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
-    exclude("**/io/objectbox/reactive/WeakDataObserver.java")
-}
-
-// Note: use packageJavadocForWeb to get as ZIP.
-// Note: the style changes only work if using JDK 10+.
-task javadocForWeb(type: Javadoc) {
-    group = 'documentation'
-    description = 'Builds Javadoc incl. objectbox-java-api classes with web tweaks.'
-
-    def srcApi = project(':objectbox-java-api').file('src/main/java/')
-    if (!srcApi.directory) throw new GradleScriptException("Not a directory: ${srcApi}", null)
-    // Hide internal API from javadoc artifact.
-    def filteredSources = sourceSets.main.allJava.matching {
-        exclude("**/io/objectbox/Cursor.java")
-        exclude("**/io/objectbox/KeyValueCursor.java")
-        exclude("**/io/objectbox/ModelBuilder.java")
-        exclude("**/io/objectbox/Properties.java")
-        exclude("**/io/objectbox/Transaction.java")
-        exclude("**/io/objectbox/model/**")
-        exclude("**/io/objectbox/ideasonly/**")
-        exclude("**/io/objectbox/internal/**")
-        exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
-        exclude("**/io/objectbox/reactive/WeakDataObserver.java")
-    }
-    source = filteredSources + srcApi
-
-    classpath = sourceSets.main.output + sourceSets.main.compileClasspath
-    destinationDir = reporting.file("web-api-docs")
-
-    title = "ObjectBox Java ${version} API"
-    options.bottom = 'Available under the Apache License, Version 2.0 - <i>Copyright &#169; 2017-2020 <a href="http://objectbox.io/">ObjectBox Ltd</a>. All Rights Reserved.</i>'
-
-    doLast {
-        // Note: frequently check the vanilla stylesheet.css if values still match.
-        def stylesheetPath = "$destinationDir/stylesheet.css"
-
-        // Primary background
-        ant.replace(file: stylesheetPath, token: "#4D7A97", value: "#17A6A6")
-
-        // "Active" background
-        ant.replace(file: stylesheetPath, token: "#F8981D", value: "#7DDC7D")
-
-        // Hover
-        ant.replace(file: stylesheetPath, token: "#bb7a2a", value: "#E61955")
-
-        // Note: in CSS stylesheets the last added rule wins, so append to default stylesheet.
-        // Code blocks
-        file(stylesheetPath).append("pre {\nwhite-space: normal;\noverflow-x: auto;\n}\n")
-        // Member summary tables
-        file(stylesheetPath).append(".memberSummary {\noverflow: auto;\n}\n")
-        // Descriptions and signatures
-        file(stylesheetPath).append(".block {\n" +
-                "    display:block;\n" +
-                "    margin:3px 10px 2px 0px;\n" +
-                "    color:#474747;\n" +
-                "    overflow:auto;\n" +
-                "}")
-    }
-}
-
-task packageJavadocForWeb(type: Zip, dependsOn: javadocForWeb) {
-    group = 'documentation'
-    description = 'Packages Javadoc incl. objectbox-java-api classes with web tweaks as ZIP.'
-
-    archiveFileName = "objectbox-java-web-api-docs.zip"
-    destinationDirectory = file("$buildDir/dist")
-
-    from reporting.file("web-api-docs")
-
-    doLast {
-        println "Javadoc for web packaged to ${file("$buildDir/dist/objectbox-java-web-api-docs.zip")}"
-    }
-}
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    archiveClassifier.set('javadoc')
-    from 'build/docs/javadoc'
-}
-
-task sourcesJar(type: Jar) {
-    from sourceSets.main.allSource
-    archiveClassifier.set('sources')
-}
-
-artifacts {
-    // java plugin adds jar.
-    archives javadocJar
-    archives sourcesJar
-}
-
-uploadArchives {
-    repositories {
-        mavenDeployer {
-            // Basic definitions are defined in root project
-            pom.project {
-                name 'ObjectBox Java (only)'
-                description 'ObjectBox is a fast NoSQL database for Objects'
-
-                licenses {
-                    license {
-                        name 'The Apache Software License, Version 2.0'
-                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-                        distribution 'repo'
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/objectbox-java/build.gradle.kts b/objectbox-java/build.gradle.kts
new file mode 100644
index 00000000..78364f9f
--- /dev/null
+++ b/objectbox-java/build.gradle.kts
@@ -0,0 +1,177 @@
+plugins {
+    id("java-library")
+    id("objectbox.publishing-conventions")
+    alias(libs.plugins.spotbugs)
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+val javadocForWebDir = layout.buildDirectory.dir("docs/web-api-docs")
+
+dependencies {
+    api(project(":objectbox-java-api"))
+    implementation(libs.essentials)
+    api(libs.jsr305)
+
+    compileOnly(libs.spotbugs.annotations)
+}
+
+spotbugs {
+    ignoreFailures.set(true)
+    showStackTraces.set(true)
+    excludeFilter.set(file("spotbugs-exclude.xml"))
+}
+
+tasks.spotbugsMain {
+    reports.create("html") {
+        required.set(true)
+    }
+}
+
+// Note: used for the Maven javadoc artifact, a separate task is used to build API docs to publish online
+tasks.javadoc {
+    // Internal Java APIs
+    exclude("**/io/objectbox/Cursor.java")
+    exclude("**/io/objectbox/InternalAccess.java")
+    exclude("**/io/objectbox/KeyValueCursor.java")
+    exclude("**/io/objectbox/ModelBuilder.java")
+    exclude("**/io/objectbox/Properties.java")
+    exclude("**/io/objectbox/Transaction.java")
+    exclude("**/io/objectbox/ideasonly/**")
+    exclude("**/io/objectbox/internal/**")
+    exclude("**/io/objectbox/query/InternalAccess.java")
+    exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
+    exclude("**/io/objectbox/reactive/WeakDataObserver.java")
+    exclude("**/io/objectbox/sync/server/ClusterPeerInfo.java")
+    // Repackaged FlatBuffers distribution
+    exclude("**/io/objectbox/flatbuffers/**")
+    // FlatBuffers generated files only used internally (note: some are part of the public API)
+    exclude("**/io/objectbox/model/**")
+    exclude("**/io/objectbox/sync/Credentials.java")
+    exclude("**/io/objectbox/sync/CredentialsType.java")
+    exclude("**/io/objectbox/sync/server/ClusterPeerConfig.java")
+    exclude("**/io/objectbox/sync/server/JwtConfig.java")
+    exclude("**/io/objectbox/sync/server/SyncServerOptions.java")
+}
+
+// Note: use packageJavadocForWeb to get as ZIP.
+val javadocForWeb by tasks.registering(Javadoc::class) {
+    group = "documentation"
+    description = "Builds Javadoc incl. objectbox-java-api classes with web tweaks."
+
+    // Register used files as inputs so task is re-run if they change
+    // https://docs.gradle.org/current/userguide/incremental_build.html
+    val customOverview = layout.projectDirectory.file("src/web/overview.html")
+    inputs.file(customOverview)
+        .withPropertyName("customOverview")
+        .withPathSensitivity(PathSensitivity.NONE)
+    val customStylesheet = layout.projectDirectory.file("src/web/objectbox-stylesheet.css")
+    inputs.file(customStylesheet)
+        .withPropertyName("customStylesheet")
+        .withPathSensitivity(PathSensitivity.NONE)
+
+    javadocTool.set(javaToolchains.javadocToolFor {
+        // Note: the style changes only work if using JDK 10+, 21 is the LTS release used to publish this
+        languageVersion.set(JavaLanguageVersion.of(21))
+    })
+
+    val srcApi = project(":objectbox-java-api").file("src/main/java/")
+    if (!srcApi.isDirectory) throw GradleException("Not a directory: $srcApi")
+    // Hide internal API from javadoc artifact.
+    val filteredSources = sourceSets.main.get().allJava.matching {
+        // Internal Java APIs
+        exclude("**/io/objectbox/Cursor.java")
+        exclude("**/io/objectbox/InternalAccess.java")
+        exclude("**/io/objectbox/KeyValueCursor.java")
+        exclude("**/io/objectbox/ModelBuilder.java")
+        exclude("**/io/objectbox/Properties.java")
+        exclude("**/io/objectbox/Transaction.java")
+        exclude("**/io/objectbox/ideasonly/**")
+        exclude("**/io/objectbox/internal/**")
+        exclude("**/io/objectbox/query/InternalAccess.java")
+        exclude("**/io/objectbox/reactive/DataPublisherUtils.java")
+        exclude("**/io/objectbox/reactive/WeakDataObserver.java")
+        exclude("**/io/objectbox/sync/server/ClusterPeerInfo.java")
+        // Repackaged FlatBuffers distribution
+        exclude("**/io/objectbox/flatbuffers/**")
+        // FlatBuffers generated files only used internally (note: some are part of the public API)
+        exclude("**/io/objectbox/model/**")
+        exclude("**/io/objectbox/sync/Credentials.java")
+        exclude("**/io/objectbox/sync/CredentialsType.java")
+        exclude("**/io/objectbox/sync/server/ClusterPeerConfig.java")
+        exclude("**/io/objectbox/sync/server/JwtConfig.java")
+        exclude("**/io/objectbox/sync/server/SyncServerOptions.java")
+    }
+    source = filteredSources + fileTree(srcApi)
+
+    classpath = sourceSets.main.get().output + sourceSets.main.get().compileClasspath
+    destinationDir = javadocForWebDir.get().asFile
+
+    title = "ObjectBox Java ${project.version} API"
+    (options as StandardJavadocDocletOptions).apply {
+        overview = customOverview.toString()
+        bottom = "Available under the Apache License, Version 2.0 - <i>Copyright &#169; 2017-2026 <a href=\"https://objectbox.io/\">ObjectBox Ltd</a>. All Rights Reserved.</i>"
+        // Customize the default stylesheet https://docs.oracle.com/en/java/javase/21/javadoc/javadoc-css-themes.html
+        // Note: the javadoc option is "--add-stylesheet", but addStringOption already ads a single dash ("-")
+        addStringOption("-add-stylesheet", customStylesheet.toString())
+    }
+
+    doLast {
+        println("Javadoc for web created at $destinationDir")
+    }
+}
+
+tasks.register<Zip>("packageJavadocForWeb") {
+    dependsOn(javadocForWeb)
+    group = "documentation"
+    description = "Packages Javadoc incl. objectbox-java-api classes with web tweaks as ZIP."
+
+    archiveFileName.set("objectbox-java-web-api-docs.zip")
+    val distDir = layout.buildDirectory.dir("dist")
+    destinationDirectory.set(distDir)
+
+    from(file(javadocForWebDir))
+
+    doLast {
+        println("Javadoc for web packaged to ${distDir.get().file("objectbox-java-web-api-docs.zip")}")
+    }
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    dependsOn(tasks.javadoc)
+    archiveClassifier.set("javadoc")
+    from("build/docs/javadoc")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    from(sourceSets.main.get().allSource)
+    archiveClassifier.set("sources")
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxJava = "objectboxJava"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxJava) {
+            artifactId = "objectbox-java"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            artifact(javadocJar)
+
+            pom {
+                name.set("ObjectBox Java API")
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxJava])
+}
diff --git a/objectbox-java/spotbugs-exclude.xml b/objectbox-java/spotbugs-exclude.xml
new file mode 100644
index 00000000..701a5970
--- /dev/null
+++ b/objectbox-java/spotbugs-exclude.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<FindBugsFilter>
+    <!-- Hint: to use regex, prefix with ~. https://spotbugs.readthedocs.io/en/stable/filter.html -->
+    <!-- Exclude FlatBuffers generated code, compare with /scripts/flatc-idls.sh of core project. -->
+    <Match>
+        <Class name="io.objectbox.DebugFlags" />
+    </Match>
+    <Match>
+        <Package name="io.objectbox.config" />
+    </Match>
+    <Match>
+        <Package name="io.objectbox.model" />
+    </Match>
+    <Match>
+        <Class name="io.objectbox.query.OrderFlags" />
+    </Match>
+    <!-- Exclude FlatBuffers source code. -->
+    <Match>
+        <Package name="io.objectbox.flatbuffers" />
+    </Match>
+</FindBugsFilter>
\ No newline at end of file
diff --git a/objectbox-java/src/main/java/io/objectbox/Box.java b/objectbox-java/src/main/java/io/objectbox/Box.java
index a87c0eb3..ef252e61 100644
--- a/objectbox-java/src/main/java/io/objectbox/Box.java
+++ b/objectbox-java/src/main/java/io/objectbox/Box.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,12 +23,12 @@
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
-import java.util.concurrent.Callable;
 
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
-import io.objectbox.annotation.apihint.Beta;
+import io.objectbox.annotation.Backlink;
+import io.objectbox.annotation.Id;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbException;
@@ -36,14 +36,16 @@
 import io.objectbox.internal.IdGetter;
 import io.objectbox.internal.ReflectionCache;
 import io.objectbox.query.QueryBuilder;
+import io.objectbox.query.QueryCondition;
 import io.objectbox.relation.RelationInfo;
+import io.objectbox.relation.ToMany;
+import io.objectbox.relation.ToOne;
 
 /**
- * A box to store objects of a particular class.
+ * A Box to put and get Objects of a specific Entity class.
  * <p>
  * Thread-safe.
  */
-@Beta
 @ThreadSafe
 @SuppressWarnings("WeakerAccess,UnusedReturnValue,unused")
 public class Box<T> {
@@ -163,20 +165,23 @@ public void closeThreadResources() {
         }
     }
 
-    void txCommitted(Transaction tx) {
-        // Thread local readers will be renewed on next get, so we do not need clean them up
-
-        Cursor<T> cursor = activeTxCursor.get();
-        if (cursor != null) {
-            activeTxCursor.remove();
-            cursor.close();
-        }
+    /**
+     * Returns if for the calling thread this has a reader Cursor.
+     */
+    boolean hasReaderCursorForCurrentThread() {
+        return threadLocalReader.get() != null;
     }
 
     /**
-     * Called by {@link BoxStore#callInReadTx(Callable)} - does not throw so caller does not need try/finally.
+     * If there is one, and it was created using the given {@code tx}, removes and closes the {@link #activeTxCursor}
+     * for the current thread.
+     * <p>
+     * This should be called before the active transaction is closed to clean up native resources.
+     * <p>
+     * Note: {@link #threadLocalReader} is either renewed by the next call to {@link #getReader()} or cleaned up by
+     * {@link #closeThreadResources()}.
      */
-    void readTxFinished(Transaction tx) {
+    void closeActiveTxCursorForCurrentThread(Transaction tx) {
         Cursor<T> cursor = activeTxCursor.get();
         if (cursor != null && cursor.getTx() == tx) {
             activeTxCursor.remove();
@@ -184,6 +189,13 @@ void readTxFinished(Transaction tx) {
         }
     }
 
+    /**
+     * Returns if for the calling thread this has a Cursor, if any, for the currently active transaction.
+     */
+    boolean hasActiveTxCursorForCurrentThread() {
+        return activeTxCursor.get() != null;
+    }
+
     /** Used by tests */
     int getPropertyId(String propertyName) {
         Cursor<T> reader = getReader();
@@ -302,6 +314,7 @@ public boolean isEmpty() {
 
     /**
      * Returns all stored Objects in this Box.
+     *
      * @return since 2.4 the returned list is always mutable (before an empty result list was immutable)
      */
     public List<T> getAll() {
@@ -318,12 +331,41 @@ public List<T> getAll() {
     }
 
     /**
-     * Puts the given object in the box (aka persisting it). If this is a new entity (its ID property is 0), a new ID
-     * will be assigned to the entity (and returned). If the entity was already put in the box before, it will be
-     * overwritten.
+     * Check if an object with the given ID exists in the database.
+     * This is more efficient than a {@link #get(long)} and comparing against null.
+     *
+     * @return true if an object with the given ID was found, false otherwise.
+     * @since 2.7
+     */
+    public boolean contains(long id) {
+        Cursor<T> reader = getReader();
+        try {
+            return reader.seek(id);
+        } finally {
+            releaseReader(reader);
+        }
+    }
+
+    /**
+     * Puts the given object and returns its (new) ID.
      * <p>
-     * Performance note: if you want to put several entities, consider {@link #put(Collection)},
-     * {@link #put(Object[])}, {@link BoxStore#runInTx(Runnable)}, etc. instead.
+     * This means that if its {@link Id @Id} property is 0 or null, it is inserted as a new object and assigned the next
+     * available ID. For example, if there is an object with ID 1 and another with ID 100, it will be assigned ID 101.
+     * The new ID is also set on the given object before this returns.
+     * <p>
+     * If instead the object has an assigned ID set, if an object with the same ID exists it is updated. Otherwise, it
+     * is inserted with that ID.
+     * <p>
+     * If the ID was not assigned before an {@link IllegalArgumentException} is thrown.
+     * <p>
+     * When the object contains {@link ToOne} or {@link ToMany} relations, they are created (or updated) to point to the
+     * (new) target objects. The target objects themselves are typically not updated or removed. To do so, put or remove
+     * them using their {@link Box}. However, for convenience, if a target object is new, it will be inserted and
+     * assigned an ID in its Box before creating or updating the relation. Also, for ToMany relations based on a
+     * {@link Backlink} the target objects are updated (to store changes in the linked ToOne or ToMany relation).
+     * <p>
+     * Performance note: if you want to put several objects, consider {@link #put(Collection)}, {@link #put(Object[])},
+     * {@link BoxStore#runInTx(Runnable)}, etc. instead.
      */
     public long put(T entity) {
         Cursor<T> cursor = getWriter();
@@ -338,6 +380,8 @@ public long put(T entity) {
 
     /**
      * Puts the given entities in a box using a single transaction.
+     * <p>
+     * See {@link #put(Object)} for more details.
      */
     @SafeVarargs // Not using T... as Object[], no ClassCastException expected.
     public final void put(@Nullable T... entities) {
@@ -358,6 +402,8 @@ public final void put(@Nullable T... entities) {
 
     /**
      * Puts the given entities in a box using a single transaction.
+     * <p>
+     * See {@link #put(Object)} for more details.
      *
      * @param entities It is fine to pass null or an empty collection:
      *                 this case is handled efficiently without overhead.
@@ -380,6 +426,8 @@ public void put(@Nullable Collection<T> entities) {
 
     /**
      * Puts the given entities in a box in batches using a separate transaction for each batch.
+     * <p>
+     * See {@link #put(Object)} for more details.
      *
      * @param entities  It is fine to pass null or an empty collection:
      *                  this case is handled efficiently without overhead.
@@ -409,8 +457,11 @@ public void putBatched(@Nullable Collection<T> entities, int batchSize) {
     }
 
     /**
-     * Removes (deletes) the Object by its ID.
-     * @return true if an entity was actually removed (false if no entity exists with the given ID)
+     * Removes (deletes) the object with the given ID.
+     * <p>
+     * If the object is part of a relation, it will be removed from that relation as well.
+     *
+     * @return true if the object did exist and was removed, otherwise false.
      */
     public boolean remove(long id) {
         Cursor<T> cursor = getWriter();
@@ -425,7 +476,7 @@ public boolean remove(long id) {
     }
 
     /**
-     * Removes (deletes) Objects by their ID in a single transaction.
+     * Like {@link #remove(long)}, but removes multiple objects in a single transaction.
      */
     public void remove(@Nullable long... ids) {
         if (ids == null || ids.length == 0) {
@@ -444,15 +495,7 @@ public void remove(@Nullable long... ids) {
     }
 
     /**
-     * @deprecated use {@link #removeByIds(Collection)} instead.
-     */
-    @Deprecated
-    public void removeByKeys(@Nullable Collection<Long> ids) {
-        removeByIds(ids);
-    }
-
-    /**
-     * Due to type erasure collision, we cannot simply use "remove" as a method name here.
+     * Like {@link #remove(long)}, but removes multiple objects in a single transaction.
      */
     public void removeByIds(@Nullable Collection<Long> ids) {
         if (ids == null || ids.isEmpty()) {
@@ -470,8 +513,7 @@ public void removeByIds(@Nullable Collection<Long> ids) {
     }
 
     /**
-     * Removes (deletes) the given Object.
-     * @return true if an entity was actually removed (false if no entity exists with the given ID)
+     * Like {@link #remove(long)}, but obtains the ID from the {@link Id @Id} property of the given object instead.
      */
     public boolean remove(T object) {
         Cursor<T> cursor = getWriter();
@@ -487,7 +529,7 @@ public boolean remove(T object) {
     }
 
     /**
-     * Removes (deletes) the given Objects in a single transaction.
+     * Like {@link #remove(Object)}, but removes multiple objects in a single transaction.
      */
     @SafeVarargs // Not using T... as Object[], no ClassCastException expected.
     @SuppressWarnings("Duplicates") // Detected duplicate has different type
@@ -508,7 +550,7 @@ public final void remove(@Nullable T... objects) {
     }
 
     /**
-     * Removes (deletes) the given Objects in a single transaction.
+     * Like {@link #remove(Object)}, but removes multiple objects in a single transaction.
      */
     @SuppressWarnings("Duplicates") // Detected duplicate has different type
     public void remove(@Nullable Collection<T> objects) {
@@ -528,7 +570,7 @@ public void remove(@Nullable Collection<T> objects) {
     }
 
     /**
-     * Removes (deletes) ALL Objects in a single transaction.
+     * Like {@link #remove(long)}, but removes <b>all</b> objects in a single transaction.
      */
     public void removeAll() {
         Cursor<T> cursor = getWriter();
@@ -552,10 +594,36 @@ public long panicModeRemoveAll() {
     }
 
     /**
-     * Returns a builder to create queries for Object matching supplied criteria.
+     * Create a query with no conditions.
+     *
+     * @see #query(QueryCondition)
      */
     public QueryBuilder<T> query() {
-        return new QueryBuilder<>(this, store.internalHandle(), store.getDbName(entityClass));
+        return new QueryBuilder<>(this, store.getNativeStore(), store.getDbName(entityClass));
+    }
+
+    /**
+     * Applies the given query conditions and returns the builder for further customization, such as result order.
+     * Build the condition using the properties from your entity underscore classes.
+     * <p>
+     * An example with a nested OR condition:
+     * <pre>
+     * # Java
+     * box.query(User_.name.equal("Jane")
+     *         .and(User_.age.less(12)
+     *                 .or(User_.status.equal("child"))));
+     *
+     * # Kotlin
+     * box.query(User_.name.equal("Jane")
+     *         and (User_.age.less(12)
+     *         or User_.status.equal("child")))
+     * </pre>
+     * This method is a shortcut for {@code query().apply(condition)}.
+     *
+     * @see QueryBuilder#apply(QueryCondition)
+     */
+    public QueryBuilder<T> query(QueryCondition<T> queryCondition) {
+        return query().apply(queryCondition);
     }
 
     public BoxStore getStore() {
@@ -574,7 +642,14 @@ public synchronized EntityInfo<T> getEntityInfo() {
         return entityInfo;
     }
 
-    @Beta
+    /**
+     * Attaches the given object to this.
+     * <p>
+     * This typically should only be used when <a
+     * href="https://docs.objectbox.io/advanced/object-ids#self-assigned-object-ids">manually assigning IDs</a>.
+     *
+     * @param entity The object to attach this to.
+     */
     public void attach(T entity) {
         if (boxStoreField == null) {
             try {
diff --git a/objectbox-java/src/main/java/io/objectbox/BoxStore.java b/objectbox-java/src/main/java/io/objectbox/BoxStore.java
index e2a20ef7..b4983ce1 100644
--- a/objectbox-java/src/main/java/io/objectbox/BoxStore.java
+++ b/objectbox-java/src/main/java/io/objectbox/BoxStore.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,9 @@
 import java.io.Closeable;
 import java.io.File;
 import java.io.IOException;
+import java.io.PrintStream;
+import java.net.MalformedURLException;
+import java.net.URL;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
@@ -33,27 +36,36 @@
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.SynchronousQueue;
+import java.util.concurrent.ThreadFactory;
 import java.util.concurrent.TimeUnit;
 
 import javax.annotation.Nullable;
 import javax.annotation.concurrent.ThreadSafe;
 
+import io.objectbox.annotation.apihint.Beta;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.config.DebugFlags;
+import io.objectbox.config.FlatStoreOptions;
 import io.objectbox.converter.PropertyConverter;
 import io.objectbox.exception.DbException;
 import io.objectbox.exception.DbExceptionListener;
 import io.objectbox.exception.DbSchemaException;
+import io.objectbox.internal.Feature;
 import io.objectbox.internal.NativeLibraryLoader;
 import io.objectbox.internal.ObjectBoxThreadPool;
 import io.objectbox.reactive.DataObserver;
 import io.objectbox.reactive.DataPublisher;
 import io.objectbox.reactive.SubscriptionBuilder;
+import io.objectbox.sync.SyncClient;
 
 /**
- * Represents an ObjectBox database and gives you {@link Box}es to get and put Objects of a specific type
- * (see {@link #boxFor(Class)}).
+ * An ObjectBox database that provides {@link Box Boxes} to put and get objects of specific entity classes
+ * (see {@link #boxFor(Class)}). To get an instance of this class use {@code MyObjectBox.builder()}.
  */
 @SuppressWarnings({"unused", "UnusedReturnValue", "SameParameterValue", "WeakerAccess"})
 @ThreadSafe
@@ -63,10 +75,26 @@ public class BoxStore implements Closeable {
     @Nullable private static Object context;
     @Nullable private static Object relinker;
 
-    /** Change so ReLinker will update native library when using workaround loading. */
-    public static final String JNI_VERSION = "2.6.0";
+    /** Prefix supplied with database directory to signal a file-less and in-memory database should be used. */
+    public static final String IN_MEMORY_PREFIX = "memory:";
 
-    private static final String VERSION = "2.6.0-2020-06-09";
+    /**
+     * ReLinker uses this as a suffix for the extracted shared library file. If different, it will update it. Should be
+     * unique to avoid conflicts.
+     */
+    public static final String JNI_VERSION = "6.0.0-2026-07-13";
+
+    /**
+     * The ObjectBox database version this Java library is known to work with.
+     * <p>
+     * This should be a version number followed by a date (MAJOR.MINOR.PATCH-YYYY-MM-DD).
+     * <p>
+     * This is used (currently only in tests) to make sure a database library has a compatible JNI API by checking the
+     * version number matches exactly and the date is the same or newer.
+     */
+    private static final String VERSION = "6.0.0-2026-07-13";
+
+    private static final String OBJECTBOX_PACKAGE_NAME = "objectbox";
     private static BoxStore defaultStore;
 
     /** Currently used DB dirs with values from {@link #getCanonicalPath(File)}. */
@@ -118,30 +146,50 @@ public static synchronized boolean clearDefaultStore() {
         return existedBefore;
     }
 
-    /** Gets the Version of ObjectBox Java. */
+    /**
+     * Returns the version of this ObjectBox Java SDK.
+     */
     public static String getVersion() {
         return VERSION;
     }
 
     static native String nativeGetVersion();
 
-    /** Gets the Version of ObjectBox Core. */
+    /**
+     * Returns the version of the loaded ObjectBox database library.
+     */
     public static String getVersionNative() {
         NativeLibraryLoader.ensureLoaded();
         return nativeGetVersion();
     }
 
     /**
-     * Diagnostics: If this method crashes on a device, please send us the logcat output.
+     * @return true if DB files did not exist or were successfully removed,
+     * false if DB files exist that could not be removed.
+     */
+    static native boolean nativeRemoveDbFiles(String directory, boolean removeDir);
+
+    /**
+     * Creates a native BoxStore instance with FlatBuffer {@link FlatStoreOptions} {@code options}
+     * and a {@link ModelBuilder} {@code model}. Returns the handle of the native store instance.
      */
-    public static native void testUnalignedMemoryAccess();
+    static native long nativeCreateWithFlatOptions(byte[] options, byte[] model);
 
-    static native long nativeCreate(String directory, long maxDbSizeInKByte, int maxReaders, byte[] model);
+    static native boolean nativeIsReadOnly(long store);
 
     static native void nativeDelete(long store);
 
     static native void nativeDropAllData(long store);
 
+    /**
+     * A static counter for the alive entity types (entity schema instances); this can be useful to test against leaks.
+     * This number depends on the number of currently opened stores; no matter how often stores were closed and
+     * (re-)opened. E.g. when stores are regularly opened, but not closed by the user, the number should increase. When
+     * all stores are properly closed, this value should be 0.
+     */
+    @Internal
+    static native long nativeGloballyActiveEntityTypes();
+
     static native long nativeBeginTx(long store);
 
     static native long nativeBeginReadTx(long store);
@@ -158,24 +206,65 @@ static native void nativeRegisterCustomType(long store, int entityId, int proper
 
     static native int nativeCleanStaleReadTransactions(long store);
 
-    static native void nativeSetDbExceptionListener(long store, DbExceptionListener dbExceptionListener);
+    static native void nativeSetDbExceptionListener(long store, @Nullable DbExceptionListener dbExceptionListener);
 
     static native void nativeSetDebugFlags(long store, int debugFlags);
 
-    static native String nativeStartObjectBrowser(long store, @Nullable String urlPath, int port);
+    private native String nativeStartObjectBrowser(long store, @Nullable String urlPath, int port);
+
+    private native boolean nativeStopObjectBrowser(long store);
 
     static native boolean nativeIsObjectBrowserAvailable();
 
+    native long nativeDbSize(long store);
+
+    native long nativeDbSizeOnDisk(long store);
+
+    native long nativeValidate(long store, long pageLimit, boolean checkLeafLevel);
+
+    static native long nativeSysProcMeminfoKb(String key);
+
+    static native long nativeSysProcStatusKb(String key);
+
+    private static native boolean nativeHasFeature(int feature);
+
+    /**
+     * Returns if the loaded database library supports the given feature.
+     *
+     * @param feature the feature to check for
+     */
+    public static boolean hasFeature(Feature feature) {
+        try {
+            NativeLibraryLoader.ensureLoaded();
+            return nativeHasFeature(feature.id);
+        } catch (UnsatisfiedLinkError e) {
+            System.err.println("Old JNI lib? " + e);  // No stack
+            return false;
+        }
+    }
+
     public static boolean isObjectBrowserAvailable() {
-        NativeLibraryLoader.ensureLoaded();
-        return nativeIsObjectBrowserAvailable();
+        return hasFeature(Feature.ADMIN);
+    }
+
+    public static boolean isSyncAvailable() {
+        return hasFeature(Feature.SYNC);
+    }
+
+    public static boolean isSyncServerAvailable() {
+        return hasFeature(Feature.SYNC_SERVER);
     }
 
     native long nativePanicModeRemoveAllObjects(long store, int entityId);
 
+    private final PrintStream errorOutputStream;
     private final File directory;
     private final String canonicalPath;
-    private final long handle;
+
+    /** Reference to the native store. Should probably get through {@link #getNativeStore()} instead. */
+    volatile private long handle;
+    volatile private boolean nativeStoreDestroyed = false;
+
     private final Map<Class<?>, String> dbNameByClass = new HashMap<>();
     private final Map<Class<?>, Integer> entityTypeIdByClass = new HashMap<>();
     private final Map<Class<?>, EntityInfo<?>> propertiesByClass = new HashMap<>();
@@ -192,7 +281,8 @@ public static boolean isObjectBrowserAvailable() {
     /** Set when running inside TX */
     final ThreadLocal<Transaction> activeTx = new ThreadLocal<>();
 
-    private boolean closed;
+    // volatile so checkOpen() is more up-to-date (no need for synchronized; it's a race anyway)
+    volatile private boolean closed;
 
     final Object txCommitCountLock = new Object();
 
@@ -205,60 +295,79 @@ public static boolean isObjectBrowserAvailable() {
 
     private final TxCallback<?> failedReadTxAttemptCallback;
 
+    /**
+     * Keeps a reference so the library user does not have to.
+     */
+    @Nullable
+    private SyncClient syncClient;
+
     BoxStore(BoxStoreBuilder builder) {
         context = builder.context;
         relinker = builder.relinker;
         NativeLibraryLoader.ensureLoaded();
 
+        errorOutputStream = builder.errorOutputStream;
         directory = builder.directory;
         canonicalPath = getCanonicalPath(directory);
         verifyNotAlreadyOpen(canonicalPath);
 
-        handle = nativeCreate(canonicalPath, builder.maxSizeInKByte, builder.maxReaders, builder.model);
-        int debugFlags = builder.debugFlags;
-        if (debugFlags != 0) {
-            nativeSetDebugFlags(handle, debugFlags);
-            debugTxRead = (debugFlags & DebugFlags.LOG_TRANSACTIONS_READ) != 0;
-            debugTxWrite = (debugFlags & DebugFlags.LOG_TRANSACTIONS_WRITE) != 0;
-        } else {
-            debugTxRead = debugTxWrite = false;
-        }
-        debugRelations = builder.debugRelations;
+        try {
+            handle = nativeCreateWithFlatOptions(builder.buildFlatStoreOptions(canonicalPath), builder.model);
+            if (handle == 0) throw new DbException("Could not create native store");
+
+            int debugFlags = builder.debugFlags;
+            if (debugFlags != 0) {
+                debugTxRead = (debugFlags & DebugFlags.LOG_TRANSACTIONS_READ) != 0;
+                debugTxWrite = (debugFlags & DebugFlags.LOG_TRANSACTIONS_WRITE) != 0;
+            } else {
+                debugTxRead = debugTxWrite = false;
+            }
+            debugRelations = builder.debugRelations;
 
-        for (EntityInfo<?> entityInfo : builder.entityInfoList) {
-            try {
-                dbNameByClass.put(entityInfo.getEntityClass(), entityInfo.getDbName());
-                int entityId = nativeRegisterEntityClass(handle, entityInfo.getDbName(), entityInfo.getEntityClass());
-                entityTypeIdByClass.put(entityInfo.getEntityClass(), entityId);
-                classByEntityTypeId.put(entityId, entityInfo.getEntityClass());
-                propertiesByClass.put(entityInfo.getEntityClass(), entityInfo);
-                for (Property<?> property : entityInfo.getAllProperties()) {
-                    if (property.customType != null) {
-                        if (property.converterClass == null) {
-                            throw new RuntimeException("No converter class for custom type of " + property);
+            for (EntityInfo<?> entityInfo : builder.entityInfoList) {
+                try {
+                    dbNameByClass.put(entityInfo.getEntityClass(), entityInfo.getDbName());
+                    int entityId = nativeRegisterEntityClass(handle, entityInfo.getDbName(), entityInfo.getEntityClass());
+                    entityTypeIdByClass.put(entityInfo.getEntityClass(), entityId);
+                    classByEntityTypeId.put(entityId, entityInfo.getEntityClass());
+                    propertiesByClass.put(entityInfo.getEntityClass(), entityInfo);
+                    for (Property<?> property : entityInfo.getAllProperties()) {
+                        if (property.customType != null) {
+                            if (property.converterClass == null) {
+                                throw new RuntimeException("No converter class for custom type of " + property);
+                            }
+                            nativeRegisterCustomType(handle, entityId, 0, property.dbName, property.converterClass,
+                                    property.customType);
                         }
-                        nativeRegisterCustomType(handle, entityId, 0, property.dbName, property.converterClass,
-                                property.customType);
                     }
+                } catch (RuntimeException e) {
+                    throw new RuntimeException("Could not setup up entity " + entityInfo.getEntityClass(), e);
                 }
-            } catch (RuntimeException e) {
-                throw new RuntimeException("Could not setup up entity " + entityInfo.getEntityClass(), e);
             }
-        }
-        int size = classByEntityTypeId.size();
-        allEntityTypeIds = new int[size];
-        long[] entityIdsLong = classByEntityTypeId.keys();
-        for (int i = 0; i < size; i++) {
-            allEntityTypeIds[i] = (int) entityIdsLong[i];
-        }
+            int size = classByEntityTypeId.size();
+            allEntityTypeIds = new int[size];
+            long[] entityIdsLong = classByEntityTypeId.keys();
+            for (int i = 0; i < size; i++) {
+                allEntityTypeIds[i] = (int) entityIdsLong[i];
+            }
 
-        objectClassPublisher = new ObjectClassPublisher(this);
+            objectClassPublisher = new ObjectClassPublisher(this);
 
-        failedReadTxAttemptCallback = builder.failedReadTxAttemptCallback;
-        queryAttempts = Math.max(builder.queryAttempts, 1);
+            failedReadTxAttemptCallback = builder.failedReadTxAttemptCallback;
+            queryAttempts = Math.max(builder.queryAttempts, 1);
+        } catch (RuntimeException runtimeException) {
+            close();  // Proper clean up, e.g. delete native handle, remove this path from openFiles
+            throw runtimeException;
+        }
     }
 
     static String getCanonicalPath(File directory) {
+        // Skip directory check if in-memory prefix is used.
+        if (directory.getPath().startsWith(IN_MEMORY_PREFIX)) {
+            // Just return the path as is (e.g. "memory:data"), safe to use for string-based open check as well.
+            return directory.getPath();
+        }
+
         if (directory.exists()) {
             if (!directory.isDirectory()) {
                 throw new DbException("Is not a directory: " + directory.getAbsolutePath());
@@ -274,16 +383,34 @@ static String getCanonicalPath(File directory) {
     }
 
     static void verifyNotAlreadyOpen(String canonicalPath) {
+        // Call isFileOpen before, but without checking the result, to try to close any unreferenced instances where
+        // it was forgotten to close them.
+        // Only obtain the lock on openFiles afterward as the checker thread created by isFileOpen needs to obtain it to
+        // do anything.
+        isFileOpen(canonicalPath);
         synchronized (openFiles) {
-            isFileOpen(canonicalPath); // for retries
             if (!openFiles.add(canonicalPath)) {
-                throw new DbException("Another BoxStore is still open for this directory: " + canonicalPath +
-                        ". Hint: for most apps it's recommended to keep a BoxStore for the app's life time.");
+                throw new DbException("Another BoxStore is still open for this directory (" + canonicalPath +
+                        "). Make sure the existing instance is explicitly closed before creating a new one.");
             }
         }
     }
 
-    /** Also retries up to 500ms to improve GC race condition situation. */
+    /**
+     * Returns if the given path is in {@link #openFiles}.
+     * <p>
+     * If it is, (creates and) briefly waits on an existing "checker" thread before checking again and returning the
+     * result.
+     * <p>
+     * The "checker" thread locks {@link #openFiles} while it triggers garbage collection and finalization in this Java
+     * Virtual Machine to try to close any unreferenced BoxStore instances. These might exist if it was forgotten to
+     * close them explicitly.
+     * <p>
+     * Note that the finalization mechanism relied upon here is scheduled for removal in future versions of Java and may
+     * already be disabled depending on JVM configuration.
+     *
+     * @see #finalize()
+     */
     static boolean isFileOpen(final String canonicalPath) {
         synchronized (openFiles) {
             if (!openFiles.contains(canonicalPath)) return false;
@@ -333,7 +460,106 @@ static boolean isFileOpenSync(String canonicalPath, boolean runFinalization) {
     }
 
     /**
-     * Explicitly call {@link #close()} instead to avoid expensive finalization.
+     * Using an Android Context and an optional database name, as configured with {@link BoxStoreBuilder#name(String)},
+     * checks if the associated database files are in use by a BoxStore instance.
+     * <p>
+     * Use this to check that database files are not open before copying or deleting them.
+     */
+    public static boolean isDatabaseOpen(Object context, @Nullable String dbNameOrNull) throws IOException {
+        File dbDir = BoxStoreBuilder.getAndroidDbDir(context, dbNameOrNull);
+        return isFileOpen(dbDir.getCanonicalPath());
+    }
+
+    /**
+     * Using an optional base directory, as configured with {@link BoxStoreBuilder#baseDirectory(File)},
+     * and an optional database name, as configured with {@link BoxStoreBuilder#name(String)},
+     * checks if the associated database files are in use by a BoxStore instance.
+     * <p>
+     * Use this to check that database files are not open before copying or deleting them.
+     */
+    public static boolean isDatabaseOpen(@Nullable File baseDirectoryOrNull,
+                                         @Nullable String dbNameOrNull) throws IOException {
+        File dbDir = BoxStoreBuilder.getDbDir(baseDirectoryOrNull, dbNameOrNull);
+        return isFileOpen(dbDir.getCanonicalPath());
+    }
+
+    /**
+     * Using a directory, as configured with {@link BoxStoreBuilder#directory(File)},
+     * checks if the associated database files are in use by a BoxStore instance.
+     * <p>
+     * Use this to check that database files are not open before copying or deleting them.
+     */
+    public static boolean isDatabaseOpen(File directory) throws IOException {
+        return isFileOpen(directory.getCanonicalPath());
+    }
+
+    /**
+     * Linux only: extracts a kB value from /proc/meminfo (system wide memory information).
+     * A couple of interesting keys (from 'man proc'):
+     * - MemTotal: Total usable RAM (i.e., physical RAM minus a few reserved bits and the kernel binary code).
+     * - MemFree:  The sum of LowFree+HighFree.
+     * - MemAvailable: An estimate of how much memory is available for starting new applications, without swapping.
+     *
+     * @param key The string identifying the wanted line from /proc/meminfo to extract a Kb value from. E.g. "MemTotal".
+     * @return Kb value or 0 on failure
+     */
+    @Experimental
+    public static long sysProcMeminfoKb(String key) {
+        NativeLibraryLoader.ensureLoaded();
+        return nativeSysProcMeminfoKb(key);
+    }
+
+    /**
+     * Linux only: extracts a kB value from /proc/self/status (process specific information).
+     * A couple of interesting keys (from 'man proc'):
+     * - VmPeak: Peak virtual memory size.
+     * - VmSize: Virtual memory size.
+     * - VmHWM: Peak resident set size ("high water mark").
+     * - VmRSS: Resident set size.  Note that the value here is the sum of RssAnon, RssFile, and RssShmem.
+     * - RssAnon: Size of resident anonymous memory.  (since Linux 4.5).
+     * - RssFile: Size of resident file mappings.  (since Linux 4.5).
+     * - RssShmem: Size of resident shared memory (includes System V shared  memory,  mappings  from  tmpfs(5),
+     * and shared anonymous mappings).  (since Linux 4.5).
+     * - VmData, VmStk, VmExe: Size of data, stack, and text segments.
+     * - VmLib: Shared library code size.
+     *
+     * @param key The string identifying the wanted line from /proc/self/status to extract a Kb value from. E.g. "VmSize".
+     * @return Kb value or 0 on failure
+     */
+    @Experimental
+    public static long sysProcStatusKb(String key) {
+        NativeLibraryLoader.ensureLoaded();
+        return nativeSysProcStatusKb(key);
+    }
+
+    /**
+     * Get the size of this store. For a disk-based store type, this corresponds to the size on disk, and for the
+     * in-memory store type, this is roughly the used memory bytes occupied by the data.
+     *
+     * @return The size in bytes of the database, or 0 if the file does not exist or some error occurred.
+     */
+    public long getDbSize() {
+        return nativeDbSize(getNativeStore());
+    }
+
+    /**
+     * The size in bytes occupied by the database on disk (if any).
+     *
+     * @return The size in bytes of the database on disk, or 0 if the underlying database is in-memory only
+     * or the size could not be determined.
+     */
+    public long getDbSizeOnDisk() {
+        return nativeDbSizeOnDisk(getNativeStore());
+    }
+
+    /**
+     * Calls {@link #close()}.
+     * <p>
+     * It is strongly recommended to instead explicitly close a Store and not rely on finalization. For example, on
+     * Android finalization has a timeout that might be exceeded if closing needs to wait on transactions to finish.
+     * <p>
+     * Also finalization is scheduled for removal in future versions of Java and may already be disabled depending on
+     * JVM configuration (see documentation on super method).
      */
     @SuppressWarnings("deprecation") // finalize()
     @Override
@@ -342,8 +568,11 @@ protected void finalize() throws Throwable {
         super.finalize();
     }
 
+    /**
+     * Verifies this has not been {@link #close() closed}.
+     */
     private void checkOpen() {
-        if (closed) {
+        if (isClosed()) {
             throw new IllegalStateException("Store is closed");
         }
     }
@@ -394,13 +623,14 @@ <T> EntityInfo<T> getEntityInfo(Class<T> entityClass) {
      */
     @Internal
     public Transaction beginTx() {
-        checkOpen();
         // Because write TXs are typically not cached, initialCommitCount is not as relevant than for read TXs.
         int initialCommitCount = commitCount;
         if (debugTxWrite) {
-            System.out.println("Begin TX with commit count " + initialCommitCount);
+            getOutput().println("Begin TX with commit count " + initialCommitCount);
         }
-        long nativeTx = nativeBeginTx(handle);
+        long nativeTx = nativeBeginTx(getNativeStore());
+        if (nativeTx == 0) throw new DbException("Could not create native transaction");
+
         Transaction tx = new Transaction(this, nativeTx, initialCommitCount);
         synchronized (transactions) {
             transactions.add(tx);
@@ -414,7 +644,6 @@ public Transaction beginTx() {
      */
     @Internal
     public Transaction beginReadTx() {
-        checkOpen();
         // initialCommitCount should be acquired before starting the tx. In race conditions, there is a chance the
         // commitCount is already outdated. That's OK because it only gives a false positive for an TX being obsolete.
         // In contrast, a false negative would make a TX falsely not considered obsolete, and thus readers would not be
@@ -422,9 +651,11 @@ public Transaction beginReadTx() {
         // TODO add multithreaded test for this
         int initialCommitCount = commitCount;
         if (debugTxRead) {
-            System.out.println("Begin read TX with commit count " + initialCommitCount);
+            getOutput().println("Begin read TX with commit count " + initialCommitCount);
         }
-        long nativeTx = nativeBeginReadTx(handle);
+        long nativeTx = nativeBeginReadTx(getNativeStore());
+        if (nativeTx == 0) throw new DbException("Could not create native read transaction");
+
         Transaction tx = new Transaction(this, nativeTx, initialCommitCount);
         synchronized (transactions) {
             transactions.add(tx);
@@ -432,40 +663,88 @@ public Transaction beginReadTx() {
         return tx;
     }
 
+    /**
+     * If this was {@link #close() closed}.
+     */
     public boolean isClosed() {
         return closed;
     }
 
     /**
-     * Closes the BoxStore and frees associated resources.
-     * This method is useful for unit tests;
-     * most real applications should open a BoxStore once and keep it open until the app dies.
+     * Whether the store was created using read-only mode.
+     * If true the schema is not updated and write transactions are not possible.
+     */
+    public boolean isReadOnly() {
+        return nativeIsReadOnly(getNativeStore());
+    }
+
+    /**
+     * Closes this BoxStore and releases associated resources.
      * <p>
-     * WARNING:
-     * This is a somewhat delicate thing to do if you have threads running that may potentially still use the BoxStore.
-     * This results in undefined behavior, including the possibility of crashing.
+     * Before calling, <b>all database operations must have finished</b> (there are no more active transactions).
+     * <p>
+     * If that is not the case, the method will briefly wait on any active transactions, but then will forcefully close
+     * them to avoid crashes and print warning messages ("Transactions are still active"). If this occurs,
+     * analyze your code to make sure all database operations, notably in other threads or data observers,
+     * are properly finished.
      */
     public void close() {
         boolean oldClosedState;
         synchronized (this) {
             oldClosedState = closed;
             if (!closed) {
+                if (objectBrowserPort != 0) { // not linked natively (yet), so clean up here
+                    try {
+                        stopObjectBrowser();
+                    } catch (Throwable e) {
+                        e.printStackTrace();
+                    }
+                }
+
                 // Closeable recommendation: mark as closed before any code that might throw.
+                // Also, before checking on transactions to avoid any new transactions from getting created
+                // (due to all Java APIs doing closed checks).
                 closed = true;
+
+                // Stop accepting new tasks (async calls, query publishers) on the internal thread pool
+                internalThreadPool().shutdown();
+                // Give running tasks some time to finish, print warnings if they do not to help callers fix their code
+                checkThreadTermination();
+
                 List<Transaction> transactionsToClose;
                 synchronized (transactions) {
+                    // Give open transactions some time to close (BoxStore.unregisterTransaction() calls notify),
+                    // 1000 ms should be long enough for most small operations and short enough to avoid ANRs on Android.
+                    if (hasActiveTransaction()) {
+                        getOutput().println("Briefly waiting for active transactions before closing the Store...");
+                        try {
+                            // It is fine to hold a lock on BoxStore.this as well as BoxStore.unregisterTransaction()
+                            // only synchronizes on "transactions".
+                            //noinspection WaitWhileHoldingTwoLocks
+                            transactions.wait(1000);
+                        } catch (InterruptedException e) {
+                            // If interrupted, continue with releasing native resources
+                        }
+                        if (hasActiveTransaction()) {
+                            getErrorOutput().println("Transactions are still active:"
+                                    + " ensure that all database operations are finished before closing the Store!");
+                        }
+                    }
                     transactionsToClose = new ArrayList<>(this.transactions);
                 }
+                // Close all transactions, including recycled (not active) ones stored in Box threadLocalReader.
+                // It is expected that this prints a warning if a transaction is not owned by the current thread.
                 for (Transaction t : transactionsToClose) {
                     t.close();
                 }
-                if (handle != 0) { // failed before native handle was created?
-                    nativeDelete(handle);
-                }
 
-                // When running the full unit test suite, we had 100+ threads before, hope this helps:
-                threadPool.shutdown();
-                checkThreadTermination();
+                long handleToDelete = handle;
+                // Make isNativeStoreClosed() return true before actually closing to avoid Transaction.close() crash
+                handle = 0;
+                if (handleToDelete != 0) { // failed before native handle was created?
+                    nativeDelete(handleToDelete);
+                    nativeStoreDestroyed = true;
+                }
             }
         }
         if (!oldClosedState) {
@@ -476,24 +755,52 @@ public void close() {
         }
     }
 
-    /** dump thread stacks if pool does not terminate promptly. */
+    /**
+     * Waits briefly for the internal {@link #internalThreadPool()} to terminate. If it does not terminate in time,
+     * prints stack traces of the pool threads.
+     */
     private void checkThreadTermination() {
         try {
-            if (!threadPool.awaitTermination(1, TimeUnit.SECONDS)) {
-                int activeCount = Thread.activeCount();
-                System.err.println("Thread pool not terminated in time; printing stack traces...");
-                Thread[] threads = new Thread[activeCount + 2];
+            if (!internalThreadPool().awaitTermination(1, TimeUnit.SECONDS)) {
+                getErrorOutput().println("ObjectBox thread pool not terminated in time." +
+                        " Ensure all async calls have completed and subscriptions are cancelled before closing the Store." +
+                        "\nDumping stack traces of threads on the pool and any using ObjectBox APIs:" +
+                        "\n=== BEGIN OF DUMP ===");
+                // Note: this may not print any pool threads if other threads are started while enumerating
+                // (and the pool threads do not make it into the threads array).
+                Thread[] threads = new Thread[Thread.activeCount()];
                 int count = Thread.enumerate(threads);
                 for (int i = 0; i < count; i++) {
-                    System.err.println("Thread: " + threads[i].getName());
-                    Thread.dumpStack();
+                    Thread thread = threads[i];
+                    if (shouldDumpThreadStackTrace(thread)) {
+                        getErrorOutput().println("Thread: " + thread.getName());
+                        StackTraceElement[] trace = thread.getStackTrace();
+                        for (StackTraceElement traceElement : trace) {
+                            getErrorOutput().println("\tat " + traceElement);
+                        }
+                    }
                 }
+                getErrorOutput().println("=== END OF DUMP ===");
             }
         } catch (InterruptedException e) {
-            e.printStackTrace();
+            e.printStackTrace(getErrorOutput());
         }
     }
 
+    private boolean shouldDumpThreadStackTrace(Thread thread) {
+        // Dump any threads of the internal thread pool
+        if (thread.getName().startsWith(ObjectBoxThreadPool.THREAD_NAME_PREFIX)) return true;
+
+        // Any other thread might be blocking a thread on the internal pool, so also dump any that appear to use
+        // ObjectBox APIs.
+        StackTraceElement[] trace = thread.getStackTrace();
+        for (StackTraceElement traceElement : trace) {
+            if (traceElement.getClassName().contains(OBJECTBOX_PACKAGE_NAME)) return true;
+        }
+
+        return false;
+    }
+
     /**
      * Danger zone! This will delete all data (files) of this BoxStore!
      * You must call {@link #close()} before and read the docs of that method carefully!
@@ -504,7 +811,7 @@ private void checkThreadTermination() {
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
      */
     public boolean deleteAllFiles() {
-        if (!closed) {
+        if (!isClosed()) {
             throw new IllegalStateException("Store must be closed");
         }
         return deleteAllFiles(directory);
@@ -513,38 +820,31 @@ public boolean deleteAllFiles() {
     /**
      * Danger zone! This will delete all files in the given directory!
      * <p>
-     * No {@link BoxStore} may be alive using the given directory.
+     * No {@link BoxStore} may be alive using the given directory. E.g. call this before building a store. When calling
+     * this after {@link #close() closing} a store, read the docs of that method carefully first!
      * <p>
-     * If you did not use a custom name with BoxStoreBuilder, you can pass "new File({@link
-     * BoxStoreBuilder#DEFAULT_NAME})".
+     * If no {@link BoxStoreBuilder#name(String) name} was specified when building the store, use like:
+     *
+     * <pre>{@code
+     *     BoxStore.deleteAllFiles(new File(BoxStoreBuilder.DEFAULT_NAME));
+     * }</pre>
+     *
+     * <p>For an {@link BoxStoreBuilder#inMemory(String) in-memory} database, this will just clean up the in-memory
+     * database.
      *
      * @param objectStoreDirectory directory to be deleted; this is the value you previously provided to {@link
-     *                             BoxStoreBuilder#directory(File)}
+     * BoxStoreBuilder#directory(File)}
      * @return true if the directory 1) was deleted successfully OR 2) did not exist in the first place.
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
-     * @throws IllegalStateException if the given directory is still used by a open {@link BoxStore}.
+     * @throws IllegalStateException if the given directory is still used by an open {@link BoxStore}.
      */
     public static boolean deleteAllFiles(File objectStoreDirectory) {
-        if (!objectStoreDirectory.exists()) {
-            return true;
-        }
-        if (isFileOpen(getCanonicalPath(objectStoreDirectory))) {
+        String canonicalPath = getCanonicalPath(objectStoreDirectory);
+        if (isFileOpen(canonicalPath)) {
             throw new IllegalStateException("Cannot delete files: store is still open");
         }
-
-        File[] files = objectStoreDirectory.listFiles();
-        if (files == null) {
-            return false;
-        }
-        for (File file : files) {
-            if (!file.delete()) {
-                // OK if concurrently deleted. Fail fast otherwise.
-                if (file.exists()) {
-                    return false;
-                }
-            }
-        }
-        return objectStoreDirectory.delete();
+        NativeLibraryLoader.ensureLoaded();
+        return nativeRemoveDbFiles(canonicalPath, true);
     }
 
     /**
@@ -555,9 +855,9 @@ public static boolean deleteAllFiles(File objectStoreDirectory) {
      * If you did not use a custom name with BoxStoreBuilder, you can pass "new File({@link
      * BoxStoreBuilder#DEFAULT_NAME})".
      *
-     * @param androidContext     provide an Android Context like Application or Service
+     * @param androidContext provide an Android Context like Application or Service
      * @param customDbNameOrNull use null for default name, or the name you previously provided to {@link
-     *                           BoxStoreBuilder#name(String)}.
+     * BoxStoreBuilder#name(String)}.
      * @return true if the directory 1) was deleted successfully OR 2) did not exist in the first place.
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
      * @throws IllegalStateException if the given name is still used by a open {@link BoxStore}.
@@ -576,9 +876,9 @@ public static boolean deleteAllFiles(Object androidContext, @Nullable String cus
      * BoxStoreBuilder#DEFAULT_NAME})".
      *
      * @param baseDirectoryOrNull use null for no base dir, or the value you previously provided to {@link
-     *                            BoxStoreBuilder#baseDirectory(File)}
-     * @param customDbNameOrNull  use null for default name, or the name you previously provided to {@link
-     *                            BoxStoreBuilder#name(String)}.
+     * BoxStoreBuilder#baseDirectory(File)}
+     * @param customDbNameOrNull use null for default name, or the name you previously provided to {@link
+     * BoxStoreBuilder#name(String)}.
      * @return true if the directory 1) was deleted successfully OR 2) did not exist in the first place.
      * Note: If false is returned, any number of files may have been deleted before the failure happened.
      * @throws IllegalStateException if the given directory (+name) is still used by a open {@link BoxStore}.
@@ -604,14 +904,32 @@ public static boolean deleteAllFiles(@Nullable File baseDirectoryOrNull, @Nullab
      * </ul>
      */
     public void removeAllObjects() {
-        nativeDropAllData(handle);
+        nativeDropAllData(getNativeStore());
     }
 
     @Internal
     public void unregisterTransaction(Transaction transaction) {
         synchronized (transactions) {
             transactions.remove(transaction);
+            // For close(): notify if there are no more open transactions
+            if (!hasActiveTransaction()) {
+                transactions.notifyAll();
+            }
+        }
+    }
+
+    /**
+     * Returns if {@link #transactions} has a single transaction that {@link Transaction#isActive() isActive()}.
+     * <p>
+     * Callers must synchronize on {@link #transactions}.
+     */
+    private boolean hasActiveTransaction() {
+        for (Transaction tx : transactions) {
+            if (tx.isActive()) {
+                return true;
+            }
         }
+        return false;
     }
 
     void txCommitted(Transaction tx, @Nullable int[] entityTypeIdsAffected) {
@@ -619,20 +937,25 @@ void txCommitted(Transaction tx, @Nullable int[] entityTypeIdsAffected) {
         synchronized (txCommitCountLock) {
             commitCount++; // Overflow is OK because we check for equality
             if (debugTxWrite) {
-                System.out.println("TX committed. New commit count: " + commitCount + ", entity types affected: " +
+                getOutput().println("TX committed. New commit count: " + commitCount + ", entity types affected: " +
                         (entityTypeIdsAffected != null ? entityTypeIdsAffected.length : 0));
             }
         }
 
-        for (Box<?> box : boxes.values()) {
-            box.txCommitted(tx);
-        }
-
         if (entityTypeIdsAffected != null) {
             objectClassPublisher.publish(entityTypeIdsAffected);
         }
     }
 
+    /**
+     * For all boxes, calls {@link Box#closeActiveTxCursorForCurrentThread(Transaction)}.
+     */
+    void closeActiveTxCursorsForCurrentThread(Transaction tx) {
+        for (Box<?> box : boxes.values()) {
+            box.closeActiveTxCursorForCurrentThread(tx);
+        }
+    }
+
     /**
      * Returns a Box for the given type. Objects are put into (and get from) their individual Box.
      * <p>
@@ -675,6 +998,7 @@ public void runInTx(Runnable runnable) {
                 tx.commit();
             } finally {
                 activeTx.remove();
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -701,13 +1025,9 @@ public void runInReadTx(Runnable runnable) {
                 runnable.run();
             } finally {
                 activeTx.remove();
-
                 // TODO That's rather a quick fix, replace with a more general solution
                 // (that could maybe be a TX listener with abort callback?)
-                for (Box<?> box : boxes.values()) {
-                    box.readTxFinished(tx);
-                }
-
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -738,10 +1058,10 @@ public <T> T callInReadTxWithRetry(Callable<T> callable, int attempts, int initi
                 String diagnose = diagnose();
                 String message = attempt + " of " + attempts + " attempts of calling a read TX failed:";
                 if (logAndHeal) {
-                    System.err.println(message);
+                    getErrorOutput().println(message);
                     e.printStackTrace();
-                    System.err.println(diagnose);
-                    System.err.flush();
+                    getErrorOutput().println(diagnose);
+                    getErrorOutput().flush();
 
                     System.gc();
                     System.runFinalization();
@@ -787,10 +1107,7 @@ public <T> T callInReadTx(Callable<T> callable) {
 
                 // TODO That's rather a quick fix, replace with a more general solution
                 // (that could maybe be a TX listener with abort callback?)
-                for (Box<?> box : boxes.values()) {
-                    box.readTxFinished(tx);
-                }
-
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -817,6 +1134,7 @@ public <R> R callInTx(Callable<R> callable) throws Exception {
                 return result;
             } finally {
                 activeTx.remove();
+                closeActiveTxCursorsForCurrentThread(tx);
                 tx.close();
             }
         } else {
@@ -846,7 +1164,7 @@ public <R> R callInTxNoException(Callable<R> callable) {
      * See also {@link #runInTx(Runnable)}.
      */
     public void runInTxAsync(final Runnable runnable, @Nullable final TxCallback<Void> callback) {
-        threadPool.submit(() -> {
+        internalScheduleThread(() -> {
             try {
                 runInTx(runnable);
                 if (callback != null) {
@@ -867,7 +1185,7 @@ public void runInTxAsync(final Runnable runnable, @Nullable final TxCallback<Voi
      * * See also {@link #callInTx(Callable)}.
      */
     public <R> void callInTxAsync(final Callable<R> callable, @Nullable final TxCallback<R> callback) {
-        threadPool.submit(() -> {
+        internalScheduleThread(() -> {
             try {
                 R result = callInTx(callable);
                 if (callback != null) {
@@ -887,17 +1205,39 @@ public <R> void callInTxAsync(final Callable<R> callable, @Nullable final TxCall
      * @return String that is typically logged by the application.
      */
     public String diagnose() {
-        return nativeDiagnose(handle);
+        return nativeDiagnose(getNativeStore());
+    }
+
+    /**
+     * Validate database pages, a lower level storage unit (integrity check).
+     * Do not call this inside a transaction (currently unsupported).
+     *
+     * @param pageLimit the maximum of pages to validate (e.g. to limit time spent on validation).
+     * Pass zero set no limit and thus validate all pages.
+     * @param checkLeafLevel Flag to validate leaf pages. These do not point to other pages but contain data.
+     * @return Number of pages validated, which may be twice the given pageLimit as internally there are "two DBs".
+     * @throws DbException if validation failed to run (does not tell anything about DB file consistency).
+     * @throws io.objectbox.exception.FileCorruptException if the DB file is actually inconsistent (corrupt).
+     */
+    @Beta
+    public long validate(long pageLimit, boolean checkLeafLevel) {
+        if (pageLimit < 0) {
+            throw new IllegalArgumentException("pageLimit must be zero or positive");
+        }
+        return nativeValidate(getNativeStore(), pageLimit, checkLeafLevel);
     }
 
     public int cleanStaleReadTransactions() {
-        return nativeCleanStaleReadTransactions(handle);
+        return nativeCleanStaleReadTransactions(getNativeStore());
     }
 
     /**
-     * Call this method from a thread that is about to be shutdown or likely not to use ObjectBox anymore:
-     * it frees any cached resources tied to the calling thread (e.g. readers). This method calls
-     * {@link Box#closeThreadResources()} for all initiated boxes ({@link #boxFor(Class)}).
+     * Frees any cached resources tied to the calling thread (e.g. readers).
+     * <p>
+     * Call this method from a thread that is about to be shut down or likely not to use ObjectBox anymore.
+     * <b>Careful:</b> ensure all transactions, like a query fetching results, have finished before.
+     * <p>
+     * This method calls {@link Box#closeThreadResources()} for all initiated boxes ({@link #boxFor(Class)}).
      */
     public void closeThreadResources() {
         for (Box<?> box : boxes.values()) {
@@ -906,11 +1246,6 @@ public void closeThreadResources() {
         // activeTx is cleaned up in finally blocks, so do not free them here
     }
 
-    @Internal
-    long internalHandle() {
-        return handle;
-    }
-
     /**
      * A {@link io.objectbox.reactive.DataObserver} can be subscribed to data changes using the returned builder.
      * The observer is supplied via {@link SubscriptionBuilder#observer(DataObserver)} and will be notified once a
@@ -924,7 +1259,18 @@ long internalHandle() {
      * Note that failed or aborted transaction do not trigger observers.
      */
     public SubscriptionBuilder<Class> subscribe() {
-        return new SubscriptionBuilder<>(objectClassPublisher, null, threadPool);
+        checkOpen();
+        return new SubscriptionBuilder<>(objectClassPublisher, null);
+    }
+
+    /**
+     * Like {@link #subscribe()}, but wires the supplied @{@link io.objectbox.reactive.DataObserver} only to the given
+     * object class for notifications.
+     */
+    @SuppressWarnings("unchecked")
+    public <T> SubscriptionBuilder<Class<T>> subscribe(Class<T> forClass) {
+        checkOpen();
+        return new SubscriptionBuilder<>((DataPublisher) objectClassPublisher, forClass);
     }
 
     @Experimental
@@ -951,18 +1297,48 @@ public String startObjectBrowser() {
     @Nullable
     public String startObjectBrowser(int port) {
         verifyObjectBrowserNotRunning();
-        String url = nativeStartObjectBrowser(handle, null, port);
+        String url = nativeStartObjectBrowser(getNativeStore(), null, port);
+        if (url != null) {
+            objectBrowserPort = port;
+        }
+        return url;
+    }
+
+    @Experimental
+    @Nullable
+    public String startObjectBrowser(String urlToBindTo) {
+        verifyObjectBrowserNotRunning();
+        int port;
+        try {
+            port = new URL(urlToBindTo).getPort(); // Gives -1 if not available
+        } catch (MalformedURLException e) {
+            throw new RuntimeException("Can not start Object Browser at " + urlToBindTo, e);
+        }
+        String url = nativeStartObjectBrowser(getNativeStore(), urlToBindTo, 0);
         if (url != null) {
             objectBrowserPort = port;
         }
         return url;
     }
 
+    @Experimental
+    public synchronized boolean stopObjectBrowser() {
+        if (objectBrowserPort == 0) {
+            throw new IllegalStateException("ObjectBrowser has not been started before");
+        }
+        objectBrowserPort = 0;
+        return nativeStopObjectBrowser(getNativeStore());
+    }
+
     @Experimental
     public int getObjectBrowserPort() {
         return objectBrowserPort;
     }
 
+    public boolean isObjectBrowserRunning() {
+        return objectBrowserPort != 0;
+    }
+
     private void verifyObjectBrowserNotRunning() {
         if (objectBrowserPort != 0) {
             throw new DbException("ObjectBrowser is already running at port " + objectBrowserPort);
@@ -970,29 +1346,75 @@ private void verifyObjectBrowserNotRunning() {
     }
 
     /**
-     * The given listener will be called when an exception is thrown.
-     * This for example allows a central error handling, e.g. a special logging for DB related exceptions.
+     * Sets a listener that will be called when an exception is thrown. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     * <p>
+     * This for example allows central error handling or special logging for database-related exceptions.
      */
-    public void setDbExceptionListener(DbExceptionListener dbExceptionListener) {
-        nativeSetDbExceptionListener(handle, dbExceptionListener);
+    public void setDbExceptionListener(@Nullable DbExceptionListener dbExceptionListener) {
+        nativeSetDbExceptionListener(getNativeStore(), dbExceptionListener);
     }
 
     /**
-     * Like {@link #subscribe()}, but wires the supplied @{@link io.objectbox.reactive.DataObserver} only to the given
-     * object class for notifications.
+     * Like {@link Executors#newCachedThreadPool()} but uses {@link ObjectBoxThreadPoolExecutor} to ensure proper
+     * cleanup of thread-local resources.
+     *
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
      */
-    @SuppressWarnings("unchecked")
-    public <T> SubscriptionBuilder<Class<T>> subscribe(Class<T> forClass) {
-        return new SubscriptionBuilder<>((DataPublisher) objectClassPublisher, forClass, threadPool);
+    public ObjectBoxThreadPoolExecutor newCachedThreadPoolExecutor() {
+        return new ObjectBoxThreadPoolExecutor(this, 0, Integer.MAX_VALUE,
+                60L, TimeUnit.SECONDS,
+                new SynchronousQueue<>());
+    }
+
+    /**
+     * Like {@link Executors#newCachedThreadPool(ThreadFactory)} but uses {@link ObjectBoxThreadPoolExecutor} to ensure
+     * proper cleanup of thread-local resources.
+     *
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newCachedThreadPoolExecutor(ThreadFactory threadFactory) {
+        return new ObjectBoxThreadPoolExecutor(this, 0, Integer.MAX_VALUE,
+                60L, TimeUnit.SECONDS,
+                new SynchronousQueue<>(),
+                threadFactory);
+    }
+
+    /**
+     * Like {@link Executors#newFixedThreadPool(int)} but uses {@link ObjectBoxThreadPoolExecutor} to ensure proper
+     * cleanup of thread-local resources.
+     *
+     * @param nThreads the number of threads in the pool
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newFixedThreadPoolExecutor(int nThreads) {
+        return new ObjectBoxThreadPoolExecutor(this, nThreads, nThreads,
+                0L, TimeUnit.MILLISECONDS,
+                new LinkedBlockingQueue<>());
+    }
+
+    /**
+     * Like {@link Executors#newFixedThreadPool(int, ThreadFactory)} but uses {@link ObjectBoxThreadPoolExecutor} to
+     * ensure proper cleanup of thread-local resources.
+     *
+     * @param nThreads the number of threads in the pool
+     * @param threadFactory the factory to use when creating new threads
+     * @return a new {@link ObjectBoxThreadPoolExecutor}
+     */
+    public ObjectBoxThreadPoolExecutor newFixedThreadPoolExecutor(int nThreads, ThreadFactory threadFactory) {
+        return new ObjectBoxThreadPoolExecutor(this, nThreads, nThreads,
+                0L, TimeUnit.MILLISECONDS,
+                new LinkedBlockingQueue<>(),
+                threadFactory);
     }
 
     @Internal
     public Future<?> internalScheduleThread(Runnable runnable) {
-        return threadPool.submit(runnable);
+        return internalThreadPool().submit(runnable);
     }
 
     @Internal
-    public ExecutorService internalThreadPool() {
+    ExecutorService internalThreadPool() {
         return threadPool;
     }
 
@@ -1011,17 +1433,34 @@ public TxCallback<?> internalFailedReadTxAttemptCallback() {
         return failedReadTxAttemptCallback;
     }
 
+    /**
+     * The output stream to print log messages to. Currently {@link System#out}.
+     */
+    private PrintStream getOutput() {
+        return System.out;
+    }
+
+    /**
+     * The error output stream to print log messages to. This is {@link System#err} by default.
+     */
+    private PrintStream getErrorOutput() {
+        return errorOutputStream;
+    }
+
     void setDebugFlags(int debugFlags) {
-        nativeSetDebugFlags(handle, debugFlags);
+        nativeSetDebugFlags(getNativeStore(), debugFlags);
     }
 
     long panicModeRemoveAllObjects(int entityId) {
-        return nativePanicModeRemoveAllObjects(handle, entityId);
+        return nativePanicModeRemoveAllObjects(getNativeStore(), entityId);
     }
 
     /**
-     * If you want to use the same ObjectBox store using the C API, e.g. via JNI, this gives the required pointer,
-     * which you have to pass on to obx_store_wrap().
+     * Gets the reference to the native store. Can be used with the C API to use the same store, e.g. via JNI, by
+     * passing it on to {@code obx_store_wrap()}.
+     * <p>
+     * Throws if the store is closed.
+     * <p>
      * The procedure is like this:<br>
      * 1) you create a BoxStore on the Java side<br>
      * 2) you call this method to get the native store pointer<br>
@@ -1032,10 +1471,47 @@ long panicModeRemoveAllObjects(int entityId) {
      * Note: Once you {@link #close()} this BoxStore, do not use it from the C API.
      */
     public long getNativeStore() {
-        if (closed) {
-            throw new IllegalStateException("Store must still be open");
-        }
+        checkOpen();
         return handle;
     }
 
+    /**
+     * For internal use only. This API might change or be removed with a future release.
+     * <p>
+     * Returns {@code true} once the native Store is about to be destroyed.
+     * <p>
+     * This is {@code true} shortly after {@link #close()} was called and {@link #isClosed()} returns {@code true}.
+     *
+     * @see #isNativeStoreDestroyed()
+     */
+    @Internal
+    public boolean isNativeStoreClosed() {
+        return handle == 0;
+    }
+
+    /**
+     * For internal use only. This API might change or be removed with a future release.
+     * <p>
+     * Returns {@code true} once the native Store was destroyed.
+     * <p>
+     * This is {@code true} shortly after {@link #isNativeStoreClosed()} returns {@code true}.
+     *
+     * @see #isNativeStoreClosed()
+     */
+    @Internal
+    public boolean isNativeStoreDestroyed() {
+        return nativeStoreDestroyed;
+    }
+
+    /**
+     * Returns the {@link SyncClient} associated with this store. To create one see {@link io.objectbox.sync.Sync Sync}.
+     */
+    @Nullable
+    public SyncClient getSyncClient() {
+        return syncClient;
+    }
+
+    void setSyncClient(@Nullable SyncClient syncClient) {
+        this.syncClient = syncClient;
+    }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java b/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java
index 583a176c..0dc5e4f8 100644
--- a/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/BoxStoreBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,6 +25,7 @@
 import java.io.FileOutputStream;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.io.PrintStream;
 import java.lang.reflect.Method;
 import java.util.ArrayList;
 import java.util.Arrays;
@@ -35,22 +36,28 @@
 
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.config.DebugFlags;
+import io.objectbox.config.FlatStoreOptions;
+import io.objectbox.config.ValidateOnOpenModeKv;
+import io.objectbox.config.ValidateOnOpenModePages;
 import io.objectbox.exception.DbException;
+import io.objectbox.exception.DbFullException;
+import io.objectbox.exception.DbMaxDataSizeExceededException;
+import io.objectbox.exception.DbMaxReadersExceededException;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
 import io.objectbox.ideasonly.ModelUpdate;
 
 /**
- * Builds a {@link BoxStore} with optional configurations. The class is not initiated directly; use
- * MyObjectBox.builder() to get an instance.
+ * Configures and builds a {@link BoxStore} with reasonable defaults. To get an instance use {@code MyObjectBox.builder()}.
  * <p>
- * Each configuration has reasonable defaults, which you can adjust.
- * For Android, you must pass a Context using {@link #androidContext(Object)}.
+ * On Android, make sure to provide a Context to {@link #androidContext(Object) androidContext(context)}.
  * <p>
- * Configurations you can override:
+ * Some common defaults to override are:
  * <ol>
- * <li>Name/location of DB: use {@link #name(String)}/{@link #baseDirectory}/{@link #androidContext(Object)}
- * OR {@link #directory(File)}(default: name "objectbox)</li>
- * <li>Max DB size: see {@link #maxSizeInKByte} (default: 1 GB)</li>
- * <li>Max readers: see {@link #maxReaders(int)} (default: 126)</li>
+ * <li>Name/location of Store: use either {@link #name(String)}, {@link #baseDirectory(File)},
+ * {@link #androidContext(Object)} or {@link #directory(File)} (default: name "objectbox),</li>
+ * <li>Max DB size: see {@link #maxSizeInKByte(long)} (default: 1024 * 1024 KB = 1 GB),</li>
+ * <li>Max readers: see {@link #maxReaders(int)} (default: 126),</li>
  * </ol>
  */
 public class BoxStoreBuilder {
@@ -61,44 +68,72 @@ public class BoxStoreBuilder {
     /** The default maximum size the DB can grow to, which can be overwritten using {@link #maxSizeInKByte}. */
     public static final int DEFAULT_MAX_DB_SIZE_KBYTE = 1024 * 1024;
 
+    /**
+     * The error output stream {@link BoxStore} uses for logging. Defaults to {@link System#err}, but can be customized
+     * for tests.
+     */
+    PrintStream errorOutputStream = System.err;
+
     final byte[] model;
 
-    /** BoxStore uses this */
+    /** BoxStore uses this (not baseDirectory/name) */
     File directory;
 
-    /** On Android used for native library loading. */
-    @Nullable Object context;
-    @Nullable Object relinker;
-
     /** Ignored by BoxStore */
     private File baseDirectory;
 
     /** Ignored by BoxStore */
     private String name;
 
+    /** If non-null, using an in-memory database with this identifier. */
+    private String inMemory;
+
     /** Defaults to {@link #DEFAULT_MAX_DB_SIZE_KBYTE}. */
     long maxSizeInKByte = DEFAULT_MAX_DB_SIZE_KBYTE;
 
+    long maxDataSizeInKByte;
+
+    /** On Android used for native library loading. */
+    @Nullable
+    Object context;
+    @Nullable
+    Object relinker;
+
     ModelUpdate modelUpdate;
 
     int debugFlags;
 
-    private boolean android;
-
     boolean debugRelations;
 
+    int fileMode;
+
     int maxReaders;
+    boolean noReaderThreadLocals;
 
     int queryAttempts;
 
+    /** For DebugCursor. */
+    boolean skipReadSchema;
+
+    boolean readOnly;
+    boolean usePreviousCommit;
+
+    short validateOnOpenModePages;
+    long validateOnOpenPageLimit;
+
+    short validateOnOpenModeKv;
+
     TxCallback<?> failedReadTxAttemptCallback;
 
     final List<EntityInfo<?>> entityInfoList = new ArrayList<>();
     private Factory<InputStream> initialDbFileFactory;
 
-    /** Not for application use. */
+    /** Not for application use, for DebugCursor. */
+    @Internal
     public static BoxStoreBuilder createDebugWithoutModel() {
-        return new BoxStoreBuilder();
+        BoxStoreBuilder builder = new BoxStoreBuilder();
+        builder.skipReadSchema = true;
+        return builder;
     }
 
     private BoxStoreBuilder() {
@@ -108,6 +143,8 @@ private BoxStoreBuilder() {
     /** Called internally from the generated class "MyObjectBox". Check MyObjectBox.builder() to get an instance. */
     @Internal
     public BoxStoreBuilder(byte[] model) {
+        // Note: annotations do not guarantee parameter is non-null.
+        //noinspection ConstantValue
         if (model == null) {
             throw new IllegalArgumentException("Model may not be null");
         }
@@ -116,16 +153,24 @@ public BoxStoreBuilder(byte[] model) {
     }
 
     /**
-     * Name of the database, which will be used as a directory for DB files.
+     * For testing: set a custom error output stream {@link BoxStore} uses for logging. Defaults to {@link System#err}.
+     */
+    @Internal
+    BoxStoreBuilder setErrorOutput(PrintStream err) {
+        errorOutputStream = err;
+        return this;
+    }
+
+    /**
+     * Name of the database, which will be used as a directory for database files.
      * You can also specify a base directory for this one using {@link #baseDirectory(File)}.
-     * Cannot be used in combination with {@link #directory(File)}.
+     * Cannot be used in combination with {@link #directory(File)} and {@link #inMemory(String)}.
      * <p>
      * Default: "objectbox", {@link #DEFAULT_NAME} (unless {@link #directory(File)} is used)
      */
     public BoxStoreBuilder name(String name) {
-        if (directory != null) {
-            throw new IllegalArgumentException("Already has directory, cannot assign name");
-        }
+        checkIsNull(directory, "Already has directory, cannot assign name");
+        checkIsNull(inMemory, "Already set to in-memory database, cannot assign name");
         if (name.contains("/") || name.contains("\\")) {
             throw new IllegalArgumentException("Name may not contain (back) slashes. " +
                     "Use baseDirectory() or directory() to configure alternative directories");
@@ -135,16 +180,28 @@ public BoxStoreBuilder name(String name) {
     }
 
     /**
-     * The directory where all DB files should be placed in.
-     * Cannot be used in combination with {@link #name(String)}/{@link #baseDirectory(File)}.
+     * The directory where all database files should be placed in.
+     * <p>
+     * If the directory does not exist, it will be created. Make sure the process has permissions to write to this
+     * directory.
+     * <p>
+     * To switch to an in-memory database, use a file path with {@link BoxStore#IN_MEMORY_PREFIX} and an identifier
+     * instead:
+     * <p>
+     * <pre>{@code
+     * BoxStore inMemoryStore = MyObjectBox.builder()
+     *     .directory(BoxStore.IN_MEMORY_PREFIX + "notes-db")
+     *     .build();
+     * }</pre>
+     * Alternatively, use {@link #inMemory(String)}.
+     * <p>
+     * Can not be used in combination with {@link #name(String)}, {@link #baseDirectory(File)}
+     * or {@link #inMemory(String)}.
      */
     public BoxStoreBuilder directory(File directory) {
-        if (name != null) {
-            throw new IllegalArgumentException("Already has name, cannot assign directory");
-        }
-        if (!android && baseDirectory != null) {
-            throw new IllegalArgumentException("Already has base directory, cannot assign directory");
-        }
+        checkIsNull(name, "Already has name, cannot assign directory");
+        checkIsNull(inMemory, "Already set to in-memory database, cannot assign directory");
+        checkIsNull(baseDirectory, "Already has base directory, cannot assign directory");
         this.directory = directory;
         return this;
     }
@@ -152,28 +209,53 @@ public BoxStoreBuilder directory(File directory) {
     /**
      * In combination with {@link #name(String)}, this lets you specify the location of where the DB files should be
      * stored.
-     * Cannot be used in combination with {@link #directory(File)}.
+     * Cannot be used in combination with {@link #directory(File)} or {@link #inMemory(String)}.
      */
     public BoxStoreBuilder baseDirectory(File baseDirectory) {
-        if (directory != null) {
-            throw new IllegalArgumentException("Already has directory, cannot assign base directory");
-        }
+        checkIsNull(directory, "Already has directory, cannot assign base directory");
+        checkIsNull(inMemory, "Already set to in-memory database, cannot assign base directory");
         this.baseDirectory = baseDirectory;
         return this;
     }
 
     /**
-     * On Android, you can pass a Context to set the base directory using this method.
-     * This will conveniently configure the storage location to be in the files directory of your app.
+     * Switches to an in-memory database using the given name as its identifier.
+     * <p>
+     * Can not be used in combination with {@link #name(String)}, {@link #directory(File)}
+     * or {@link #baseDirectory(File)}.
+     */
+    public BoxStoreBuilder inMemory(String identifier) {
+        checkIsNull(name, "Already has name, cannot switch to in-memory database");
+        checkIsNull(directory, "Already has directory, cannot switch to in-memory database");
+        checkIsNull(baseDirectory, "Already has base directory, cannot switch to in-memory database");
+        inMemory = identifier;
+        return this;
+    }
+
+    /**
+     * Use to check conflicting properties are not set.
+     * If not null, throws {@link IllegalStateException} with the given message.
+     */
+    private static void checkIsNull(@Nullable Object value, String errorMessage) {
+        if (value != null) {
+            throw new IllegalStateException(errorMessage);
+        }
+    }
+
+    /**
+     * Use on Android to pass a <a href="https://developer.android.com/reference/android/content/Context">Context</a>
+     * for loading the native library and, if not an {@link #inMemory(String)} database, for creating the base
+     * directory for database files in the
+     * <a href="https://developer.android.com/reference/android/content/Context#getFilesDir()">files directory of the app</a>.
      * <p>
-     * In more detail, this assigns the base directory (see {@link #baseDirectory}) to
+     * In more detail, upon {@link #build()} assigns the base directory (see {@link #baseDirectory}) to
      * {@code context.getFilesDir() + "/objectbox/"}.
-     * Thus, when using the default name (also "objectbox" unless overwritten using {@link #name(String)}), the default
-     * location of DB files will be "objectbox/objectbox/" inside the app files directory.
-     * If you specify a custom name, for example with {@code name("foobar")}, it would become
-     * "objectbox/foobar/".
+     * Thus, when using the default name (also "objectbox", unless overwritten using {@link #name(String)}), the default
+     * location of database files will be "objectbox/objectbox/" inside the app's files directory.
+     * If a custom name is specified, for example with {@code name("foobar")}, it would become "objectbox/foobar/".
      * <p>
-     * Alternatively, you can also use {@link #baseDirectory} or {@link #directory(File)} instead.
+     * Use {@link #baseDirectory(File)} or {@link #directory(File)} to specify a different directory for the database
+     * files.
      */
     public BoxStoreBuilder androidContext(Object context) {
         //noinspection ConstantConditions Annotation does not enforce non-null.
@@ -181,19 +263,6 @@ public BoxStoreBuilder androidContext(Object context) {
             throw new NullPointerException("Context may not be null");
         }
         this.context = getApplicationContext(context);
-
-        File baseDir = getAndroidBaseDir(context);
-        if (!baseDir.exists()) {
-            baseDir.mkdir();
-            if (!baseDir.exists()) { // check baseDir.exists() because of potential concurrent processes
-                throw new RuntimeException("Could not init Android base dir at " + baseDir.getAbsolutePath());
-            }
-        }
-        if (!baseDir.isDirectory()) {
-            throw new RuntimeException("Android base dir is not a dir: " + baseDir.getAbsolutePath());
-        }
-        baseDirectory = baseDir;
-        android = true;
         return this;
     }
 
@@ -260,21 +329,48 @@ private static File getAndroidFilesDir(Object context) {
     }
 
     /**
-     * Sets the maximum number of concurrent readers. For most applications, the default is fine (&gt; 100 readers).
+     * Specify
+     * <a href="https://en.wikipedia.org/wiki/File_system_permissions#Numeric_notation">unix-style file permissions</a>
+     * for database files. E.g. for {@code -rw-r----} (owner, group, other) pass the octal code {@code 0640}.
+     * Any newly generated directory additionally gets searchable (01) for groups with read or write permissions.
+     * It's not allowed to pass in an executable flag.
+     */
+    public BoxStoreBuilder fileMode(int mode) {
+        this.fileMode = mode;
+        return this;
+    }
+
+    /**
+     * Sets the maximum number of concurrent readers. For most applications, the default is fine (about 126 readers).
      * <p>
-     * A "reader" is short for a thread involved in a read transaction.
+     * A "reader" is short for a thread involved in a read transaction. If the maximum is exceeded the store throws
+     * {@link DbMaxReadersExceededException}. In this case check that your code only uses a reasonable amount of
+     * threads.
      * <p>
-     * If you hit {@link io.objectbox.exception.DbMaxReadersExceededException}, you should first worry about the
-     * amount of threads you are using.
      * For highly concurrent setups (e.g. you are using ObjectBox on the server side) it may make sense to increase the
      * number.
+     * <p>
+     * Note: Each thread that performed a read transaction and is still alive holds on to a reader slot.
+     * These slots only get vacated when the thread ends. Thus, be mindful with the number of active threads.
+     * Alternatively, you can try the experimental {@link #noReaderThreadLocals()} option flag.
      */
-
     public BoxStoreBuilder maxReaders(int maxReaders) {
         this.maxReaders = maxReaders;
         return this;
     }
 
+    /**
+     * Disables the usage of thread locals for "readers" related to read transactions.
+     * This can make sense if you are using a lot of threads that are kept alive.
+     * <p>
+     * Note: This is still experimental, as it comes with subtle behavior changes at a low level and may affect
+     * corner cases with e.g. transactions, which may not be fully tested at the moment.
+     */
+    public BoxStoreBuilder noReaderThreadLocals() {
+        this.noReaderThreadLocals = true;
+        return this;
+    }
+
     @Internal
     public void entity(EntityInfo<?> entityInfo) {
         entityInfoList.add(entityInfo);
@@ -289,22 +385,130 @@ BoxStoreBuilder modelUpdate(ModelUpdate modelUpdate) {
 
     /**
      * Sets the maximum size the database file can grow to.
-     * By default this is 1 GB, which should be sufficient for most applications.
      * <p>
-     * In general, a maximum size prevents the DB from growing indefinitely when something goes wrong
-     * (for example you insert data in an infinite loop).
+     * The Store will throw when the file size is about to be exceeded, see {@link DbFullException} for details.
+     * <p>
+     * By default, this is 1 GB, which should be sufficient for most applications. In general, a maximum size prevents
+     * the database from growing indefinitely when something goes wrong (for example data is put in an infinite loop).
+     * <p>
+     * This can be set to a value different, so higher or also lower, from when last building the Store.
      */
     public BoxStoreBuilder maxSizeInKByte(long maxSizeInKByte) {
+        if (maxSizeInKByte <= maxDataSizeInKByte) {
+            throw new IllegalArgumentException("maxSizeInKByte must be larger than maxDataSizeInKByte.");
+        }
         this.maxSizeInKByte = maxSizeInKByte;
         return this;
     }
 
     /**
-     * @deprecated Use {@link #debugFlags} instead.
+     * Sets the maximum size the data stored in the database can grow to.
+     * When applying a transaction (e.g. putting an object) would exceed it a {@link DbMaxDataSizeExceededException}
+     * is thrown.
+     * <p>
+     * Must be below {@link #maxSizeInKByte(long)}.
+     * <p>
+     * Different from {@link #maxSizeInKByte(long)} this only counts bytes stored in objects, excluding system and
+     * metadata. However, it is more involved than database size tracking, e.g. it stores an internal counter.
+     * Only use this if a stricter, more accurate limit is required.
+     * <p>
+     * When the data limit is reached, data can be removed to get below the limit again (assuming the database size limit
+     * is not also reached).
      */
-    @Deprecated
-    public BoxStoreBuilder debugTransactions() {
-        this.debugFlags |= DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE;
+    public BoxStoreBuilder maxDataSizeInKByte(long maxDataSizeInKByte) {
+        if (maxDataSizeInKByte >= maxSizeInKByte) {
+            throw new IllegalArgumentException("maxDataSizeInKByte must be smaller than maxSizeInKByte.");
+        }
+        this.maxDataSizeInKByte = maxDataSizeInKByte;
+        return this;
+    }
+
+    /**
+     * Open the store in read-only mode: no schema update, no write transactions are allowed (would throw).
+     */
+    public BoxStoreBuilder readOnly() {
+        this.readOnly = true;
+        return this;
+    }
+
+    /**
+     * Ignores the latest data snapshot (committed transaction state) and uses the previous snapshot instead.
+     * When used with care (e.g. backup the DB files first), this option may also recover data removed by the latest
+     * transaction.
+     * <p>
+     * To ensure no data is lost accidentally, it is recommended to use this in combination with {@link #readOnly()}
+     * to examine and validate the database first.
+     */
+    public BoxStoreBuilder usePreviousCommit() {
+        this.usePreviousCommit = true;
+        return this;
+    }
+
+    /**
+     * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+     * Reliable file systems already guarantee consistency, so this is primarily meant to deal with unreliable
+     * OSes, file systems, or hardware.
+     * <p>
+     * Note: ObjectBox builds upon ACID storage, which already has strong consistency mechanisms in place.
+     * <p>
+     * See also {@link #validateOnOpenPageLimit(long)} to fine-tune this check and {@link #validateOnOpenKv(short)} for
+     * additional checks.
+     *
+     * @param validateOnOpenModePages One of {@link ValidateOnOpenModePages}.
+     */
+    public BoxStoreBuilder validateOnOpen(short validateOnOpenModePages) {
+        if (validateOnOpenModePages < ValidateOnOpenModePages.None
+                || validateOnOpenModePages > ValidateOnOpenModePages.Full) {
+            throw new IllegalArgumentException("Must be one of ValidateOnOpenModePages");
+        }
+        this.validateOnOpenModePages = validateOnOpenModePages;
+        return this;
+    }
+
+    /**
+     * To fine-tune {@link #validateOnOpen(short)}, you can specify a limit on how much data is looked at.
+     * This is measured in "pages" with a page typically holding 4000.
+     * Usually a low number (e.g. 1-20) is sufficient and does not impact startup performance significantly.
+     * <p>
+     * This can only be used with {@link ValidateOnOpenModePages#Regular} and
+     * {@link ValidateOnOpenModePages#WithLeaves}.
+     */
+    public BoxStoreBuilder validateOnOpenPageLimit(long limit) {
+        if (validateOnOpenModePages != ValidateOnOpenModePages.Regular &&
+                validateOnOpenModePages != ValidateOnOpenModePages.WithLeaves) {
+            throw new IllegalStateException("Must call validateOnOpen(mode) with mode Regular or WithLeaves first");
+        }
+        if (limit < 1) {
+            throw new IllegalArgumentException("limit must be positive");
+        }
+        this.validateOnOpenPageLimit = limit;
+        return this;
+    }
+
+    /**
+     * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+     * This enables validation checks on a key/value level.
+     * <p>
+     * This is a shortcut for {@link #validateOnOpenKv(short) validateOnOpenKv(ValidateOnOpenModeKv.Regular)}.
+     */
+    public BoxStoreBuilder validateOnOpenKv() {
+        this.validateOnOpenModeKv = ValidateOnOpenModeKv.Regular;
+        return this;
+    }
+
+    /**
+     * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+     * This enables validation checks on a key/value level.
+     * <p>
+     * See also {@link #validateOnOpen(short)} for additional consistency checks.
+     *
+     * @param mode One of {@link ValidateOnOpenModeKv}.
+     */
+    public BoxStoreBuilder validateOnOpenKv(short mode) {
+        if (mode < ValidateOnOpenModeKv.Regular || mode > ValidateOnOpenModeKv.Regular) {
+            throw new IllegalArgumentException("Must be one of ValidateOnOpenModeKv");
+        }
+        this.validateOnOpenModeKv = mode;
         return this;
     }
 
@@ -327,11 +531,11 @@ public BoxStoreBuilder debugRelations() {
     /**
      * For massive concurrent setups (app is using a lot of threads), you can enable automatic retries for queries.
      * This can resolve situations in which resources are getting sparse (e.g.
-     * {@link io.objectbox.exception.DbMaxReadersExceededException} or other variations of
-     * {@link io.objectbox.exception.DbException} are thrown during query execution).
+     * {@link DbMaxReadersExceededException} or other variations of
+     * {@link DbException} are thrown during query execution).
      *
      * @param queryAttempts number of attempts a query find operation will be executed before failing.
-     *                      Recommended values are in the range of 2 to 5, e.g. a value of 3 as a starting point.
+     * Recommended values are in the range of 2 to 5, e.g. a value of 3 as a starting point.
      */
     @Experimental
     public BoxStoreBuilder queryAttempts(int queryAttempts) {
@@ -370,15 +574,73 @@ public BoxStoreBuilder initialDbFile(Factory<InputStream> initialDbFileFactory)
         return this;
     }
 
+    byte[] buildFlatStoreOptions(String canonicalPath) {
+        FlatBufferBuilder fbb = new FlatBufferBuilder();
+        // Always put values, even if they match the default values (defined in the generated classes)
+        fbb.forceDefaults(true);
+
+        // Add non-integer values first...
+        int directoryPathOffset = fbb.createString(canonicalPath);
+
+        FlatStoreOptions.startFlatStoreOptions(fbb);
+
+        // ...then build options.
+        FlatStoreOptions.addDirectoryPath(fbb, directoryPathOffset);
+        FlatStoreOptions.addMaxDbSizeInKbyte(fbb, maxSizeInKByte);
+        FlatStoreOptions.addFileMode(fbb, fileMode);
+        FlatStoreOptions.addMaxReaders(fbb, maxReaders);
+        if (validateOnOpenModePages != 0) {
+            FlatStoreOptions.addValidateOnOpenPages(fbb, validateOnOpenModePages);
+            if (validateOnOpenPageLimit != 0) {
+                FlatStoreOptions.addValidateOnOpenPageLimit(fbb, validateOnOpenPageLimit);
+            }
+        }
+        if (validateOnOpenModeKv != 0) {
+            FlatStoreOptions.addValidateOnOpenKv(fbb, validateOnOpenModeKv);
+        }
+        if (skipReadSchema) FlatStoreOptions.addSkipReadSchema(fbb, true);
+        if (usePreviousCommit) FlatStoreOptions.addUsePreviousCommit(fbb, true);
+        if (readOnly) FlatStoreOptions.addReadOnly(fbb, true);
+        if (noReaderThreadLocals) FlatStoreOptions.addNoReaderThreadLocals(fbb, true);
+        if (debugFlags != 0) FlatStoreOptions.addDebugFlags(fbb, debugFlags);
+        if (maxDataSizeInKByte > 0) FlatStoreOptions.addMaxDataSizeInKbyte(fbb, maxDataSizeInKByte);
+
+        int offset = FlatStoreOptions.endFlatStoreOptions(fbb);
+        fbb.finish(offset);
+        return fbb.sizedByteArray();
+    }
+
     /**
-     * Builds a {@link BoxStore} using any given configuration.
+     * Builds a {@link BoxStore} using the current configuration of this builder.
+     *
+     * <p>If {@link #androidContext(Object)} was called and no {@link #directory(File)} or {@link #baseDirectory(File)}
+     * is configured, creates and sets {@link #baseDirectory(File)} as explained in {@link #androidContext(Object)}.
      */
     public BoxStore build() {
+        // If in-memory, use a special directory (it will never be created)
+        if (inMemory != null) {
+            directory = new File(BoxStore.IN_MEMORY_PREFIX + inMemory);
+        }
+        // On Android, create and set base directory if no directory is explicitly configured
+        if (directory == null && baseDirectory == null && context != null) {
+            File baseDir = getAndroidBaseDir(context);
+            if (!baseDir.exists()) {
+                baseDir.mkdir();
+                if (!baseDir.exists()) { // check baseDir.exists() because of potential concurrent processes
+                    throw new RuntimeException("Could not init Android base dir at " + baseDir.getAbsolutePath());
+                }
+            }
+            if (!baseDir.isDirectory()) {
+                throw new RuntimeException("Android base dir is not a dir: " + baseDir.getAbsolutePath());
+            }
+            baseDirectory = baseDir;
+        }
         if (directory == null) {
-            name = dbName(name);
             directory = getDbDir(baseDirectory, name);
         }
-        checkProvisionInitialDbFile();
+        if (inMemory == null) {
+            checkProvisionInitialDbFile();
+        }
         return new BoxStore(this);
     }
 
@@ -424,7 +686,52 @@ static File getDbDir(@Nullable File baseDirectoryOrNull, @Nullable String nameOr
      */
     public BoxStore buildDefault() {
         BoxStore store = build();
-        BoxStore.setDefault(store);
+        try {
+            BoxStore.setDefault(store);
+        } catch (IllegalStateException e) {
+            // Clean up the new store if it can't be set as default
+            store.close();
+            throw e;
+        }
         return store;
     }
-}
+
+
+    @Internal
+    BoxStoreBuilder createClone(String namePostfix) {
+        if (model == null) {
+            throw new IllegalStateException("BoxStoreBuilder must have a model");
+        }
+        if (initialDbFileFactory != null) {
+            throw new IllegalStateException("Initial DB files factories are not supported for sync-enabled DBs");
+        }
+
+        BoxStoreBuilder clone = new BoxStoreBuilder(model);
+        // Note: don't use absolute path for directories; it messes with in-memory paths ("memory:")
+        clone.directory = this.directory != null ? new File(this.directory.getPath() + namePostfix) : null;
+        clone.baseDirectory = this.baseDirectory != null ? new File(this.baseDirectory.getPath()) : null;
+        clone.name = this.name != null ? name + namePostfix : null;
+        clone.inMemory = this.inMemory;
+        clone.maxSizeInKByte = this.maxSizeInKByte;
+        clone.maxDataSizeInKByte = this.maxDataSizeInKByte;
+        clone.context = this.context;
+        clone.relinker = this.relinker;
+        clone.debugFlags = this.debugFlags;
+        clone.debugRelations = this.debugRelations;
+        clone.fileMode = this.fileMode;
+        clone.maxReaders = this.maxReaders;
+        clone.noReaderThreadLocals = this.noReaderThreadLocals;
+        clone.queryAttempts = this.queryAttempts;
+        clone.skipReadSchema = this.skipReadSchema;
+        clone.readOnly = this.readOnly;
+        clone.usePreviousCommit = this.usePreviousCommit;
+        clone.validateOnOpenModePages = this.validateOnOpenModePages;
+        clone.validateOnOpenPageLimit = this.validateOnOpenPageLimit;
+        clone.validateOnOpenModeKv = this.validateOnOpenModeKv;
+
+        clone.initialDbFileFactory = this.initialDbFileFactory;
+        clone.entityInfoList.addAll(this.entityInfoList); // Entity info is stateless & immutable; shallow clone is OK
+
+        return clone;
+    }
+}
\ No newline at end of file
diff --git a/objectbox-java/src/main/java/io/objectbox/Cursor.java b/objectbox-java/src/main/java/io/objectbox/Cursor.java
index abbcc58b..82954c05 100644
--- a/objectbox-java/src/main/java/io/objectbox/Cursor.java
+++ b/objectbox-java/src/main/java/io/objectbox/Cursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -106,6 +106,38 @@ protected static native long collect004000(long cursor, long keyIfComplete, int
                                                int idLong3, long valueLong3, int idLong4, long valueLong4
     );
 
+    // STRING ARRAYS
+    protected static native long collectStringArray(long cursor, long keyIfComplete, int flags,
+                                                    int idStringArray, @Nullable String[] stringArray
+    );
+
+    protected static native long collectStringList(long cursor, long keyIfComplete, int flags,
+                                                   int idStringList, @Nullable List<String> stringList
+    );
+
+    // INTEGER ARRAYS
+    protected static native long collectBooleanArray(long cursor, long keyIfComplete, int flags,
+                                                   int propertyId, @Nullable boolean[] value);
+
+    protected static native long collectShortArray(long cursor, long keyIfComplete, int flags,
+                                                   int propertyId, @Nullable short[] value);
+
+    protected static native long collectCharArray(long cursor, long keyIfComplete, int flags,
+                                                  int propertyId, @Nullable char[] value);
+
+    protected static native long collectIntArray(long cursor, long keyIfComplete, int flags,
+                                                 int propertyId, @Nullable int[] value);
+
+    protected static native long collectLongArray(long cursor, long keyIfComplete, int flags,
+                                                  int propertyId, @Nullable long[] value);
+
+    // FLOATING POINT ARRAYS
+    protected static native long collectFloatArray(long cursor, long keyIfComplete, int flags,
+                                                   int propertyId, @Nullable float[] value);
+
+    protected static native long collectDoubleArray(long cursor, long keyIfComplete, int flags,
+                                                    int propertyId, @Nullable double[] value);
+
     native int nativePropertyId(long cursor, String propertyValue);
 
     native List<T> nativeGetBacklinkEntities(long cursor, int entityId, int propertyId, long key);
@@ -320,9 +352,9 @@ public void modifyRelationsSingle(int relationId, long key, long targetKey, bool
         nativeModifyRelationsSingle(cursor, relationId, key, targetKey, remove);
     }
 
-    protected <TARGET> void checkApplyToManyToDb(List<TARGET> orders, Class<TARGET> targetClass) {
-        if (orders instanceof ToMany) {
-            ToMany<TARGET> toMany = (ToMany<TARGET>) orders;
+    protected <TARGET> void checkApplyToManyToDb(List<TARGET> relationField, Class<TARGET> targetClass) {
+        if (relationField instanceof ToMany) {
+            ToMany<TARGET> toMany = (ToMany<TARGET>) relationField;
             if (toMany.internalCheckApplyToDbRequired()) {
                 try (Cursor<TARGET> targetCursor = getRelationTargetCursor(targetClass)) {
                     toMany.internalApplyToDb(this, targetCursor);
diff --git a/objectbox-java/src/main/java/io/objectbox/EntityInfo.java b/objectbox-java/src/main/java/io/objectbox/EntityInfo.java
index 3b561fdd..5493c9df 100644
--- a/objectbox-java/src/main/java/io/objectbox/EntityInfo.java
+++ b/objectbox-java/src/main/java/io/objectbox/EntityInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/Factory.java b/objectbox-java/src/main/java/io/objectbox/Factory.java
index 78020b23..95f2f7c5 100644
--- a/objectbox-java/src/main/java/io/objectbox/Factory.java
+++ b/objectbox-java/src/main/java/io/objectbox/Factory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/InternalAccess.java b/objectbox-java/src/main/java/io/objectbox/InternalAccess.java
index 9c858ccc..2f203749 100644
--- a/objectbox-java/src/main/java/io/objectbox/InternalAccess.java
+++ b/objectbox-java/src/main/java/io/objectbox/InternalAccess.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,49 +16,71 @@
 
 package io.objectbox;
 
+import javax.annotation.Nullable;
+
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.SyncClient;
 
+/**
+ * Exposes internal APIs to tests and code in other packages.
+ */
 @Internal
 public class InternalAccess {
-    public static <T> Cursor<T> getReader(Box<T> box) {
-        return box.getReader();
-    }
 
-    public static long getHandle(Cursor reader) {
-        return reader.internalHandle();
+    @Internal
+    public static Transaction getActiveTx(BoxStore boxStore) {
+        Transaction tx = boxStore.activeTx.get();
+        if (tx == null) {
+            throw new IllegalStateException("No active transaction");
+        }
+        tx.checkOpen();
+        return tx;
     }
 
+    @Internal
     public static long getHandle(Transaction tx) {
         return tx.internalHandle();
     }
 
-    public static <T> void releaseReader(Box<T> box, Cursor<T> reader) {
-        box.releaseReader(reader);
+    @Internal
+    public static void setSyncClient(BoxStore boxStore, @Nullable SyncClient syncClient) {
+        boxStore.setSyncClient(syncClient);
     }
 
+    @Internal
     public static <T> Cursor<T> getWriter(Box<T> box) {
         return box.getWriter();
     }
 
+    @Internal
     public static <T> Cursor<T> getActiveTxCursor(Box<T> box) {
         return box.getActiveTxCursor();
     }
 
+    @Internal
     public static <T> long getActiveTxCursorHandle(Box<T> box) {
         return box.getActiveTxCursor().internalHandle();
     }
 
-    public static <T> void releaseWriter(Box<T> box, Cursor<T> writer) {
-        box.releaseWriter(writer);
-    }
-
+    @Internal
     public static <T> void commitWriter(Box<T> box, Cursor<T> writer) {
         box.commitWriter(writer);
     }
 
-    /** Makes creation more expensive, but lets Finalizers show the creation stack for dangling resources. */
+    /**
+     * Makes creation more expensive, but lets Finalizers show the creation stack for dangling resources.
+     * <p>
+     * Currently used by integration tests.
+     */
+    @SuppressWarnings("unused")
+    @Internal
     public static void enableCreationStackTracking() {
         Transaction.TRACK_CREATION_STACK = true;
         Cursor.TRACK_CREATION_STACK = true;
     }
+
+    @Internal
+    public static BoxStoreBuilder clone(BoxStoreBuilder original, String namePostfix) {
+        return original.createClone(namePostfix);
+    }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java b/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java
index fec5b72a..b9945c8a 100644
--- a/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java
+++ b/objectbox-java/src/main/java/io/objectbox/KeyValueCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java b/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java
index cc1efa41..460e9178 100644
--- a/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/ModelBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,60 +16,136 @@
 
 package io.objectbox;
 
-import com.google.flatbuffers.FlatBufferBuilder;
-
 import java.util.ArrayList;
 import java.util.List;
 
 import javax.annotation.Nullable;
 
+import io.objectbox.annotation.ExternalName;
+import io.objectbox.annotation.ExternalType;
+import io.objectbox.annotation.HnswIndex;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.model.ExternalPropertyType;
+import io.objectbox.model.HnswDistanceType;
+import io.objectbox.model.HnswFlags;
+import io.objectbox.model.HnswParams;
 import io.objectbox.model.IdUid;
 import io.objectbox.model.Model;
 import io.objectbox.model.ModelEntity;
 import io.objectbox.model.ModelProperty;
 import io.objectbox.model.ModelRelation;
 
-// Remember: IdUid is a struct, not a table, and thus must be inlined
-@SuppressWarnings("WeakerAccess,UnusedReturnValue, unused")
+// To learn how to use the FlatBuffers API see https://flatbuffers.dev/tutorial/
+// Note: IdUid is a struct, not a table, and thus must be inlined
+
+/**
+ * Builds a flatbuffer representation of the database model to be passed to {@link BoxStoreBuilder}.
+ * <p>
+ * This is an internal API that should only be called by the generated MyObjectBox code.
+ */
 @Internal
 public class ModelBuilder {
+
+    /**
+     * The version of the model (structure). The database verifies it supports this version of a model.
+     * <p>
+     * Note this is different from the "modelVersion" in the model JSON file, which only refers to the JSON schema.
+     */
     private static final int MODEL_VERSION = 2;
+    private static final String DEFAULT_NAME = "default";
+    private static final int DEFAULT_VERSION = 1;
 
-    final FlatBufferBuilder fbb = new FlatBufferBuilder();
-    final List<Integer> entityOffsets = new ArrayList<>();
+    private final FlatBufferBuilder fbb = new FlatBufferBuilder();
+    private final List<Integer> entityOffsets = new ArrayList<>();
 
-    long version = 1;
+    private long version = DEFAULT_VERSION;
 
-    Integer lastEntityId;
-    Long lastEntityUid;
+    private Integer lastEntityId;
+    private Long lastEntityUid;
 
-    Integer lastIndexId;
-    Long lastIndexUid;
+    private Integer lastIndexId;
+    private Long lastIndexUid;
 
-    Integer lastRelationId;
-    Long lastRelationUid;
+    private Integer lastRelationId;
+    private Long lastRelationUid;
+
+    /**
+     * Base class for builders.
+     * <p>
+     * Methods adding properties to be used by {@link #createFlatBufferTable(FlatBufferBuilder)} should call
+     * {@link #checkNotFinished()}.
+     * <p>
+     * The last call should be {@link #finish()}.
+     */
+    abstract static class PartBuilder {
+
+        private final FlatBufferBuilder fbb;
+        private boolean finished;
+
+        PartBuilder(FlatBufferBuilder fbb) {
+            this.fbb = fbb;
+        }
+
+        FlatBufferBuilder getFbb() {
+            return fbb;
+        }
+
+        void checkNotFinished() {
+            if (finished) {
+                throw new IllegalStateException("Already finished");
+            }
+        }
+
+        /**
+         * Marks this as finished and returns {@link #createFlatBufferTable(FlatBufferBuilder)}.
+         */
+        public final int finish() {
+            checkNotFinished();
+            finished = true;
+            return createFlatBufferTable(getFbb());
+        }
+
+        /**
+         * Creates a flatbuffer table using the given builder and returns its offset.
+         */
+        public abstract int createFlatBufferTable(FlatBufferBuilder fbb);
+    }
+
+    public static class PropertyBuilder extends PartBuilder {
 
-    public class PropertyBuilder {
-        private final int type;
-        private final int virtualTargetOffset;
         private final int propertyNameOffset;
         private final int targetEntityOffset;
+        private final int virtualTargetOffset;
+        private final int type;
 
         private int secondaryNameOffset;
-        boolean finished;
-        private int flags;
         private int id;
         private long uid;
         private int indexId;
         private long indexUid;
         private int indexMaxValueLength;
+        private int externalNameOffset;
+        private int externalType;
+        private int hnswParamsOffset;
+        private int flags;
 
-        PropertyBuilder(String name, @Nullable String targetEntityName, @Nullable String virtualTarget, int type) {
-            this.type = type;
+        private PropertyBuilder(FlatBufferBuilder fbb, String name, @Nullable String targetEntityName,
+                                @Nullable String virtualTarget, int type) {
+            super(fbb);
             propertyNameOffset = fbb.createString(name);
             targetEntityOffset = targetEntityName != null ? fbb.createString(targetEntityName) : 0;
             virtualTargetOffset = virtualTarget != null ? fbb.createString(virtualTarget) : 0;
+            this.type = type;
+        }
+
+        /**
+         * Sets the Java name of a renamed property when using {@link io.objectbox.annotation.NameInDb}.
+         */
+        public PropertyBuilder secondaryName(String secondaryName) {
+            checkNotFinished();
+            secondaryNameOffset = getFbb().createString(secondaryName);
+            return this;
         }
 
         public PropertyBuilder id(int id, long uid) {
@@ -92,38 +168,86 @@ public PropertyBuilder indexMaxValueLength(int indexMaxValueLength) {
             return this;
         }
 
-        public PropertyBuilder flags(int flags) {
+        /**
+         * Sets the {@link ExternalName} of this property.
+         */
+        public PropertyBuilder externalName(String externalName) {
             checkNotFinished();
-            this.flags = flags;
+            externalNameOffset = getFbb().createString(externalName);
             return this;
         }
 
-        public PropertyBuilder secondaryName(String secondaryName) {
+        /**
+         * Sets the {@link ExternalType} of this property. Should be one of {@link ExternalPropertyType}.
+         */
+        public PropertyBuilder externalType(int externalType) {
             checkNotFinished();
-            secondaryNameOffset = fbb.createString(secondaryName);
+            this.externalType = externalType;
             return this;
         }
 
-        private void checkNotFinished() {
-            if (finished) {
-                throw new IllegalStateException("Already finished");
+        /**
+         * Set parameters for {@link HnswIndex}.
+         *
+         * @param dimensions see {@link HnswIndex#dimensions()}.
+         * @param neighborsPerNode see {@link HnswIndex#neighborsPerNode()}.
+         * @param indexingSearchCount see {@link HnswIndex#indexingSearchCount()}.
+         * @param flags see {@link HnswIndex#flags()}, mapped to {@link HnswFlags}.
+         * @param distanceType see {@link HnswIndex#distanceType()}, mapped to {@link HnswDistanceType}.
+         * @param reparationBacklinkProbability see {@link HnswIndex#reparationBacklinkProbability()}.
+         * @param vectorCacheHintSizeKb see {@link HnswIndex#vectorCacheHintSizeKB()}.
+         * @return this builder.
+         */
+        public PropertyBuilder hnswParams(long dimensions,
+                                          @Nullable Long neighborsPerNode,
+                                          @Nullable Long indexingSearchCount,
+                                          @Nullable Integer flags,
+                                          @Nullable Short distanceType,
+                                          @Nullable Float reparationBacklinkProbability,
+                                          @Nullable Long vectorCacheHintSizeKb) {
+            checkNotFinished();
+            FlatBufferBuilder fbb = getFbb();
+            HnswParams.startHnswParams(fbb);
+            HnswParams.addDimensions(fbb, dimensions);
+            if (neighborsPerNode != null) {
+                HnswParams.addNeighborsPerNode(fbb, neighborsPerNode);
+            }
+            if (indexingSearchCount != null) {
+                HnswParams.addIndexingSearchCount(fbb, indexingSearchCount);
+            }
+            if (flags != null) {
+                HnswParams.addFlags(fbb, flags);
+            }
+            if (distanceType != null) {
+                HnswParams.addDistanceType(fbb, distanceType);
+            }
+            if (reparationBacklinkProbability != null) {
+                HnswParams.addReparationBacklinkProbability(fbb, reparationBacklinkProbability);
+            }
+            if (vectorCacheHintSizeKb != null) {
+                HnswParams.addVectorCacheHintSizeKb(fbb, vectorCacheHintSizeKb);
             }
+            hnswParamsOffset = HnswParams.endHnswParams(fbb);
+            return this;
         }
 
-        public int finish() {
+        /**
+         * One or more of {@link io.objectbox.model.PropertyFlags}.
+         */
+        public PropertyBuilder flags(int flags) {
             checkNotFinished();
-            finished = true;
+            this.flags = flags;
+            return this;
+        }
+
+        @Override
+        public int createFlatBufferTable(FlatBufferBuilder fbb) {
             ModelProperty.startModelProperty(fbb);
             ModelProperty.addName(fbb, propertyNameOffset);
-            if (targetEntityOffset != 0) {
-                ModelProperty.addTargetEntity(fbb, targetEntityOffset);
-            }
-            if (virtualTargetOffset != 0) {
-                ModelProperty.addVirtualTarget(fbb, virtualTargetOffset);
-            }
-            if (secondaryNameOffset != 0) {
-                ModelProperty.addNameSecondary(fbb, secondaryNameOffset);
-            }
+            if (targetEntityOffset != 0) ModelProperty.addTargetEntity(fbb, targetEntityOffset);
+            if (virtualTargetOffset != 0) ModelProperty.addVirtualTarget(fbb, virtualTargetOffset);
+            ModelProperty.addType(fbb, type);
+            if (secondaryNameOffset != 0) ModelProperty.addNameSecondary(fbb, secondaryNameOffset);
             if (id != 0) {
                 int idOffset = IdUid.createIdUid(fbb, id, uid);
                 ModelProperty.addId(fbb, idOffset);
@@ -132,31 +256,89 @@ public int finish() {
                 int indexIdOffset = IdUid.createIdUid(fbb, indexId, indexUid);
                 ModelProperty.addIndexId(fbb, indexIdOffset);
             }
-            if (indexMaxValueLength > 0) {
-                ModelProperty.addMaxIndexValueLength(fbb, indexMaxValueLength);
-            }
-            ModelProperty.addType(fbb, type);
-            if (flags != 0) {
-                ModelProperty.addFlags(fbb, flags);
-            }
+            if (indexMaxValueLength > 0) ModelProperty.addMaxIndexValueLength(fbb, indexMaxValueLength);
+            if (externalNameOffset != 0) ModelProperty.addExternalName(fbb, externalNameOffset);
+            if (externalType != 0) ModelProperty.addExternalType(fbb, externalType);
+            if (hnswParamsOffset != 0) ModelProperty.addHnswParams(fbb, hnswParamsOffset);
+            if (flags != 0) ModelProperty.addFlags(fbb, flags);
             return ModelProperty.endModelProperty(fbb);
         }
     }
 
-    public class EntityBuilder {
-        final String name;
-        final List<Integer> propertyOffsets = new ArrayList<>();
-        final List<Integer> relationOffsets = new ArrayList<>();
+    public static class RelationBuilder extends PartBuilder {
+
+        private final String name;
+        private final int relationId;
+        private final long relationUid;
+        private final int targetEntityId;
+        private final long targetEntityUid;
+
+        private int externalNameOffset;
+        private int externalType;
+
+        private RelationBuilder(FlatBufferBuilder fbb, String name, int relationId, long relationUid,
+                                int targetEntityId, long targetEntityUid) {
+            super(fbb);
+            this.name = name;
+            this.relationId = relationId;
+            this.relationUid = relationUid;
+            this.targetEntityId = targetEntityId;
+            this.targetEntityUid = targetEntityUid;
+        }
+
+        /**
+         * Sets the {@link ExternalName} of this relation.
+         */
+        public RelationBuilder externalName(String externalName) {
+            checkNotFinished();
+            externalNameOffset = getFbb().createString(externalName);
+            return this;
+        }
+
+        /**
+         * Sets the {@link ExternalType} of this relation. Should be one of {@link ExternalPropertyType}.
+         */
+        public RelationBuilder externalType(int externalType) {
+            checkNotFinished();
+            this.externalType = externalType;
+            return this;
+        }
+
+        @Override
+        public int createFlatBufferTable(FlatBufferBuilder fbb) {
+            int nameOffset = fbb.createString(name);
 
-        Integer id;
-        Long uid;
-        Integer flags;
-        Integer lastPropertyId;
-        Long lastPropertyUid;
-        PropertyBuilder propertyBuilder;
-        boolean finished;
+            ModelRelation.startModelRelation(fbb);
+            ModelRelation.addName(fbb, nameOffset);
+            int relationIdOffset = IdUid.createIdUid(fbb, relationId, relationUid);
+            ModelRelation.addId(fbb, relationIdOffset);
+            int targetEntityIdOffset = IdUid.createIdUid(fbb, targetEntityId, targetEntityUid);
+            ModelRelation.addTargetEntityId(fbb, targetEntityIdOffset);
+            if (externalNameOffset != 0) ModelRelation.addExternalName(fbb, externalNameOffset);
+            if (externalType != 0) ModelRelation.addExternalType(fbb, externalType);
+            return ModelRelation.endModelRelation(fbb);
+        }
+    }
 
-        EntityBuilder(String name) {
+    public static class EntityBuilder extends PartBuilder {
+
+        private final ModelBuilder model;
+        private final String name;
+        private final List<Integer> propertyOffsets = new ArrayList<>();
+        private final List<Integer> relationOffsets = new ArrayList<>();
+
+        private Integer id;
+        private Long uid;
+        private Integer lastPropertyId;
+        private Long lastPropertyUid;
+        @Nullable private String externalName;
+        private Integer flags;
+        @Nullable private PropertyBuilder propertyBuilder;
+        @Nullable private RelationBuilder relationBuilder;
+
+        private EntityBuilder(ModelBuilder model, FlatBufferBuilder fbb, String name) {
+            super(fbb);
+            this.model = model;
             this.name = name;
         }
 
@@ -174,15 +356,21 @@ public EntityBuilder lastPropertyId(int lastPropertyId, long lastPropertyUid) {
             return this;
         }
 
-        public EntityBuilder flags(int flags) {
-            this.flags = flags;
+        /**
+         * Sets the {@link ExternalName} of this entity.
+         */
+        public EntityBuilder externalName(String externalName) {
+            checkNotFinished();
+            this.externalName = externalName;
             return this;
         }
 
-        private void checkNotFinished() {
-            if (finished) {
-                throw new IllegalStateException("Already finished");
-            }
+        /**
+         * One or more of {@link io.objectbox.model.EntityFlags}.
+         */
+        public EntityBuilder flags(int flags) {
+            this.flags = flags;
+            return this;
         }
 
         public PropertyBuilder property(String name, int type) {
@@ -193,49 +381,63 @@ public PropertyBuilder property(String name, @Nullable String targetEntityName,
             return property(name, targetEntityName, null, type);
         }
 
+        /**
+         * @param name The name of this property in the database.
+         * @param targetEntityName For {@link io.objectbox.model.PropertyType#Relation}, the name of the target entity.
+         * @param virtualTarget For {@link io.objectbox.model.PropertyType#Relation}, if this property does not really
+         * exist in the source code and is a virtual one, the name of the field this is based on that actually exists.
+         * Currently used for ToOne fields that create virtual target ID properties.
+         * @param type The {@link io.objectbox.model.PropertyType}.
+         */
         public PropertyBuilder property(String name, @Nullable String targetEntityName, @Nullable String virtualTarget,
                                         int type) {
             checkNotFinished();
-            checkFinishProperty();
-            propertyBuilder = new PropertyBuilder(name, targetEntityName, virtualTarget, type);
+            finishPropertyOrRelation();
+            propertyBuilder = new PropertyBuilder(getFbb(), name, targetEntityName, virtualTarget, type);
             return propertyBuilder;
         }
 
-        void checkFinishProperty() {
+        public RelationBuilder relation(String name, int relationId, long relationUid, int targetEntityId,
+                                        long targetEntityUid) {
+            checkNotFinished();
+            finishPropertyOrRelation();
+
+            RelationBuilder relationBuilder = new RelationBuilder(getFbb(), name, relationId, relationUid, targetEntityId, targetEntityUid);
+            this.relationBuilder = relationBuilder;
+            return relationBuilder;
+        }
+
+        private void finishPropertyOrRelation() {
+            if (propertyBuilder != null && relationBuilder != null) {
+                throw new IllegalStateException("Must not build property and relation at the same time.");
+            }
             if (propertyBuilder != null) {
                 propertyOffsets.add(propertyBuilder.finish());
                 propertyBuilder = null;
             }
+            if (relationBuilder != null) {
+                relationOffsets.add(relationBuilder.finish());
+                relationBuilder = null;
+            }
         }
 
-        public EntityBuilder relation(String name, int relationId, long relationUid, int targetEntityId,
-                                      long targetEntityUid) {
+        public ModelBuilder entityDone() {
+            // Make sure any pending property or relation is finished first
             checkNotFinished();
-            checkFinishProperty();
-
-            int propertyNameOffset = fbb.createString(name);
-
-            ModelRelation.startModelRelation(fbb);
-            ModelRelation.addName(fbb, propertyNameOffset);
-            int relationIdOffset = IdUid.createIdUid(fbb, relationId, relationUid);
-            ModelRelation.addId(fbb, relationIdOffset);
-            int targetEntityIdOffset = IdUid.createIdUid(fbb, targetEntityId, targetEntityUid);
-            ModelRelation.addTargetEntityId(fbb, targetEntityIdOffset);
-            relationOffsets.add(ModelRelation.endModelRelation(fbb));
-
-            return this;
+            finishPropertyOrRelation();
+            model.entityOffsets.add(finish());
+            return model;
         }
 
-        public ModelBuilder entityDone() {
-            checkNotFinished();
-            checkFinishProperty();
-            finished = true;
-            int testEntityNameOffset = fbb.createString(name);
-            int propertiesOffset = createVector(propertyOffsets);
-            int relationsOffset = relationOffsets.isEmpty() ? 0 : createVector(relationOffsets);
+        @Override
+        public int createFlatBufferTable(FlatBufferBuilder fbb) {
+            int nameOffset = fbb.createString(name);
+            int externalNameOffset = externalName != null ? fbb.createString(externalName) : 0;
+            int propertiesOffset = model.createVector(propertyOffsets);
+            int relationsOffset = relationOffsets.isEmpty() ? 0 : model.createVector(relationOffsets);
 
             ModelEntity.startModelEntity(fbb);
-            ModelEntity.addName(fbb, testEntityNameOffset);
+            ModelEntity.addName(fbb, nameOffset);
             ModelEntity.addProperties(fbb, propertiesOffset);
             if (relationsOffset != 0) ModelEntity.addRelations(fbb, relationsOffset);
             if (id != null && uid != null) {
@@ -246,15 +448,14 @@ public ModelBuilder entityDone() {
                 int idOffset = IdUid.createIdUid(fbb, lastPropertyId, lastPropertyUid);
                 ModelEntity.addLastPropertyId(fbb, idOffset);
             }
-            if (flags != null) {
-                ModelEntity.addFlags(fbb, flags);
-            }
-            entityOffsets.add(ModelEntity.endModelEntity(fbb));
-            return ModelBuilder.this;
+            if (externalNameOffset != 0) ModelEntity.addExternalName(fbb, externalNameOffset);
+            if (flags != null) ModelEntity.addFlags(fbb, flags);
+            return ModelEntity.endModelEntity(fbb);
         }
+
     }
 
-    int createVector(List<Integer> offsets) {
+    private int createVector(List<Integer> offsets) {
         int[] offsetArray = new int[offsets.size()];
         for (int i = 0; i < offsets.size(); i++) {
             offsetArray[i] = offsets.get(i);
@@ -262,13 +463,18 @@ int createVector(List<Integer> offsets) {
         return fbb.createVectorOfTables(offsetArray);
     }
 
+    /**
+     * Sets the user-defined version of the schema this represents. Defaults to 1.
+     * <p>
+     * Currently unused.
+     */
     public ModelBuilder version(long version) {
         this.version = version;
         return this;
     }
 
     public EntityBuilder entity(String name) {
-        return new EntityBuilder(name);
+        return new EntityBuilder(this, fbb, name);
     }
 
     public ModelBuilder lastEntityId(int lastEntityId, long lastEntityUid) {
@@ -290,12 +496,12 @@ public ModelBuilder lastRelationId(int lastRelationId, long lastRelationUid) {
     }
 
     public byte[] build() {
-        int nameOffset = fbb.createString("default");
+        int nameOffset = fbb.createString(DEFAULT_NAME);
         int entityVectorOffset = createVector(entityOffsets);
         Model.startModel(fbb);
         Model.addName(fbb, nameOffset);
         Model.addModelVersion(fbb, MODEL_VERSION);
-        Model.addVersion(fbb, 1);
+        Model.addVersion(fbb, version);
         Model.addEntities(fbb, entityVectorOffset);
         if (lastEntityId != null) {
             int idOffset = IdUid.createIdUid(fbb, lastEntityId, lastEntityUid);
diff --git a/objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java b/objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java
new file mode 100644
index 00000000..52eeb881
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/ObjectBoxThreadPoolExecutor.java
@@ -0,0 +1,133 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.RejectedExecutionHandler;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.ThreadPoolExecutor;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * A {@link ThreadPoolExecutor} that automatically releases thread-local ObjectBox resources after each task execution
+ * by calling {@link BoxStore#closeThreadResources()}.
+ * <p>
+ * This is useful when using a thread pool with ObjectBox to ensure that thread-local resources (currently readers only)
+ * are properly cleaned up after each task completes.
+ * <p>
+ * <b>Recommended:</b> Use the factory methods {@link BoxStore#newFixedThreadPoolExecutor(int)} or
+ * {@link BoxStore#newCachedThreadPoolExecutor()} to create instances of this executor.
+ * <p>
+ * Example usage:
+ * <pre>
+ * BoxStore boxStore = MyObjectBox.builder().build();
+ *
+ * // Recommended: Use BoxStore factory methods
+ * ObjectBoxThreadPoolExecutor executor = boxStore.newFixedThreadPoolExecutor(4);
+ *
+ * // Or for a cached thread pool
+ * ObjectBoxThreadPoolExecutor cachedExecutor = boxStore.newCachedThreadPoolExecutor();
+ *
+ * // Advanced: Direct construction for custom configuration
+ * ObjectBoxThreadPoolExecutor customExecutor = new ObjectBoxThreadPoolExecutor(
+ *     boxStore,
+ *     4, // core pool size
+ *     8, // maximum pool size
+ *     60L, TimeUnit.SECONDS, // keep-alive time
+ *     new LinkedBlockingQueue&lt;&gt;()
+ * );
+ * </pre>
+ */
+public class ObjectBoxThreadPoolExecutor extends ThreadPoolExecutor {
+
+    private final BoxStore boxStore;
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue)} for parameter
+     * details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory)} for
+     * parameter details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       ThreadFactory threadFactory) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See
+     * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, RejectedExecutionHandler)}
+     * for parameter details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       RejectedExecutionHandler handler) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, handler);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Creates a new ObjectBoxThreadPoolExecutor with the given parameters.
+     * <p>
+     * See
+     * {@link ThreadPoolExecutor#ThreadPoolExecutor(int, int, long, TimeUnit, BlockingQueue, ThreadFactory,
+     * RejectedExecutionHandler)} for parameter details.
+     *
+     * @param boxStore the BoxStore instance for which to close thread resources
+     */
+    public ObjectBoxThreadPoolExecutor(BoxStore boxStore, int corePoolSize, int maximumPoolSize,
+                                       long keepAliveTime, TimeUnit unit,
+                                       BlockingQueue<Runnable> workQueue,
+                                       ThreadFactory threadFactory,
+                                       RejectedExecutionHandler handler) {
+        super(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue, threadFactory, handler);
+        this.boxStore = boxStore;
+    }
+
+    /**
+     * Releases thread-local ObjectBox resources after each task execution.
+     */
+    @Override
+    protected void afterExecute(Runnable runnable, Throwable throwable) {
+        super.afterExecute(runnable, throwable);
+        boxStore.closeThreadResources();
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java b/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java
index 9adc0c41..6001e293 100644
--- a/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java
+++ b/objectbox-java/src/main/java/io/objectbox/ObjectClassPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,9 +16,6 @@
 
 package io.objectbox;
 
-import org.greenrobot.essentials.collections.MultimapSet;
-import org.greenrobot.essentials.collections.MultimapSet.SetType;
-
 import java.util.ArrayDeque;
 import java.util.Collection;
 import java.util.Collections;
@@ -31,12 +28,33 @@
 import io.objectbox.reactive.DataObserver;
 import io.objectbox.reactive.DataPublisher;
 import io.objectbox.reactive.DataPublisherUtils;
+import io.objectbox.reactive.SubscriptionBuilder;
+import org.greenrobot.essentials.collections.MultimapSet;
+import org.greenrobot.essentials.collections.MultimapSet.SetType;
 
+/**
+ * A {@link DataPublisher} that notifies {@link DataObserver}s about changes in an entity box.
+ * Publishing is requested when a subscription is {@link SubscriptionBuilder#observer(DataObserver) observed} and
+ * then by {@link BoxStore} for each {@link BoxStore#txCommitted(Transaction, int[]) txCommitted}.
+ * Publish requests are processed on a single thread, one at a time, in the order publishing was requested.
+ */
+@SuppressWarnings("rawtypes")
 @Internal
 class ObjectClassPublisher implements DataPublisher<Class>, Runnable {
     final BoxStore boxStore;
     final MultimapSet<Integer, DataObserver<Class>> observersByEntityTypeId = MultimapSet.create(SetType.THREAD_SAFE);
-    final Deque<int[]> changesQueue = new ArrayDeque<>();
+    private final Deque<PublishRequest> changesQueue = new ArrayDeque<>();
+
+    private static class PublishRequest {
+        @Nullable private final DataObserver<Class> observer;
+        private final int[] entityTypeIds;
+
+        PublishRequest(@Nullable DataObserver<Class> observer, int[] entityTypeIds) {
+            this.observer = observer;
+            this.entityTypeIds = entityTypeIds;
+        }
+    }
+
     volatile boolean changePublisherRunning;
 
     ObjectClassPublisher(BoxStore boxStore) {
@@ -76,36 +94,24 @@ private void unsubscribe(DataObserver<Class> observer, int entityTypeId) {
     }
 
     @Override
-    public void publishSingle(final DataObserver<Class> observer, @Nullable final Object forClass) {
-        boxStore.internalScheduleThread(() -> {
-            Collection<Class<?>> entityClasses = forClass != null ? Collections.singletonList((Class<?>) forClass) :
-                    boxStore.getAllEntityClasses();
-            for (Class<?> entityClass : entityClasses) {
-                try {
-                    observer.onData(entityClass);
-                } catch (RuntimeException e) {
-                    handleObserverException(entityClass);
-                }
-            }
-        });
+    public void publishSingle(DataObserver<Class> observer, @Nullable Object forClass) {
+        int[] entityTypeIds = forClass != null
+                ? new int[]{boxStore.getEntityTypeIdOrThrow((Class) forClass)}
+                : boxStore.getAllEntityTypeIds();
+        queuePublishRequestAndScheduleRun(observer, entityTypeIds);
     }
 
-    private void handleObserverException(Class objectClass) {
-        RuntimeException newEx = new RuntimeException(
-                "Observer failed while processing data for " + objectClass +
-                        ". Consider using an ErrorObserver");
-        // So it won't be swallowed by thread pool
-        newEx.printStackTrace();
-        throw newEx;
+    void publish(int[] entityTypeIdsAffected) {
+        queuePublishRequestAndScheduleRun(null, entityTypeIdsAffected);
     }
 
     /**
      * Non-blocking: will just enqueue the changes for a separate thread.
      */
-    void publish(int[] entityTypeIdsAffected) {
+    private void queuePublishRequestAndScheduleRun(@Nullable DataObserver<Class> observer, int[] entityTypeIds) {
         synchronized (changesQueue) {
-            changesQueue.add(entityTypeIdsAffected);
-            // Only one thread at a time
+            changesQueue.add(new PublishRequest(observer, entityTypeIds));
+            // Only one thread at a time.
             if (!changePublisherRunning) {
                 changePublisherRunning = true;
                 boxStore.internalScheduleThread(this);
@@ -113,30 +119,41 @@ void publish(int[] entityTypeIdsAffected) {
         }
     }
 
+    /**
+     * Processes publish requests using a single thread to prevent any data generated by observers to get stale.
+     * This publisher on its own can NOT deliver stale data (the entity class types do not change).
+     * However, a {@link DataObserver} of this publisher might apply a {@link io.objectbox.reactive.DataTransformer}
+     * which queries for data which CAN get stale if delivered out of order.
+     */
     @Override
     public void run() {
         try {
             while (true) {
-                // We do not join all available array, just in case the app relies on a specific order
-                int[] entityTypeIdsAffected;
+                PublishRequest request;
                 synchronized (changesQueue) {
-                    entityTypeIdsAffected = changesQueue.pollFirst();
-                    if (entityTypeIdsAffected == null) {
+                    request = changesQueue.pollFirst();
+                    if (request == null) {
                         changePublisherRunning = false;
                         break;
                     }
                 }
-                for (int entityTypeId : entityTypeIdsAffected) {
-                    Collection<DataObserver<Class>> observers = observersByEntityTypeId.get(entityTypeId);
-                    if (observers != null && !observers.isEmpty()) {
-                        Class<?> objectClass = boxStore.getEntityClassOrThrow(entityTypeId);
-                        try {
-                            for (DataObserver<Class> observer : observers) {
-                                observer.onData(objectClass);
-                            }
-                        } catch (RuntimeException e) {
-                            handleObserverException(objectClass);
+
+                for (int entityTypeId : request.entityTypeIds) {
+                    // If no specific observer specified, notify all current observers.
+                    Collection<DataObserver<Class>> observers = request.observer != null
+                            ? Collections.singletonList(request.observer)
+                            : observersByEntityTypeId.get(entityTypeId);
+                    if (observers == null || observers.isEmpty()) {
+                        continue; // No observers for this entity type.
+                    }
+
+                    Class entityClass = boxStore.getEntityClassOrThrow(entityTypeId);
+                    try {
+                        for (DataObserver<Class> observer : observers) {
+                            observer.onData(entityClass);
                         }
+                    } catch (RuntimeException e) {
+                        handleObserverException(entityClass);
                     }
                 }
             }
@@ -145,4 +162,13 @@ public void run() {
             changePublisherRunning = false;
         }
     }
+
+    private void handleObserverException(Class objectClass) {
+        RuntimeException newEx = new RuntimeException(
+                "Observer failed while processing data for " + objectClass +
+                        ". Consider using an ErrorObserver");
+        // So it won't be swallowed by thread pool
+        newEx.printStackTrace();
+        throw newEx;
+    }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/Property.java b/objectbox-java/src/main/java/io/objectbox/Property.java
index af7ff7cb..13a4ccae 100644
--- a/objectbox-java/src/main/java/io/objectbox/Property.java
+++ b/objectbox-java/src/main/java/io/objectbox/Property.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,20 +17,38 @@
 package io.objectbox;
 
 import java.io.Serializable;
-import java.util.Collection;
+import java.util.Date;
 
 import javax.annotation.Nullable;
 
+import io.objectbox.annotation.HnswIndex;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.converter.PropertyConverter;
 import io.objectbox.exception.DbException;
-import io.objectbox.query.QueryCondition;
-import io.objectbox.query.QueryCondition.PropertyCondition;
-import io.objectbox.query.QueryCondition.PropertyCondition.Operation;
+import io.objectbox.query.PropertyQueryCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.ByteArrayCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.DoubleCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.DoubleDoubleCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.IntArrayCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.LongArrayCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.LongCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.LongLongCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.NearestNeighborCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.NullCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.StringArrayCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.StringCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.StringCondition.Operation;
+import io.objectbox.query.PropertyQueryConditionImpl.StringDoubleCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.StringLongCondition;
+import io.objectbox.query.PropertyQueryConditionImpl.StringStringCondition;
+import io.objectbox.query.Query;
+import io.objectbox.query.QueryBuilder.StringOrder;
 
 /**
- * Meta data describing a property of an ObjectBox entity.
- * Properties are typically used to define query criteria using {@link io.objectbox.query.QueryBuilder}.
+ * Meta data describing a Property of an ObjectBox Entity.
+ * Properties are typically used when defining {@link Query Query} conditions
+ * using {@link io.objectbox.query.QueryBuilder QueryBuilder}.
+ * Access properties using the generated underscore class of an entity (e.g. {@code Example_.id}).
  */
 @SuppressWarnings("WeakerAccess,UnusedReturnValue, unused")
 public class Property<ENTITY> implements Serializable {
@@ -47,7 +65,9 @@ public class Property<ENTITY> implements Serializable {
     public final boolean isId;
     public final boolean isVirtual;
     public final String dbName;
-    public final Class<? extends PropertyConverter<?, ?>> converterClass;
+    @SuppressWarnings("rawtypes")
+    // Use raw type of PropertyConverter to allow users to supply a generic implementation.
+    public final Class<? extends PropertyConverter> converterClass;
 
     /** Type, which is converted to a type supported by the DB. */
     public final Class<?> customType;
@@ -69,16 +89,19 @@ public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, S
         this(entity, ordinal, id, type, name, isId, dbName, null, null);
     }
 
-    // Note: types of PropertyConverter might not exactly match type and customtype, e.g. if using generics like List.class.
+    @SuppressWarnings("rawtypes")
+    // Use raw type of PropertyConverter to allow users to supply a generic implementation.
     public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, String name, boolean isId,
-                    @Nullable String dbName, @Nullable Class<? extends PropertyConverter<?, ?>> converterClass,
+                    @Nullable String dbName, @Nullable Class<? extends PropertyConverter> converterClass,
                     @Nullable Class<?> customType) {
         this(entity, ordinal, id, type, name, isId, false, dbName, converterClass, customType);
     }
 
+    @SuppressWarnings("rawtypes")
+    // Use raw type of PropertyConverter to allow users to supply a generic implementation.
     public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, String name, boolean isId,
                     boolean isVirtual, @Nullable String dbName,
-                    @Nullable Class<? extends PropertyConverter<?, ?>> converterClass, @Nullable Class<?> customType) {
+                    @Nullable Class<? extends PropertyConverter> converterClass, @Nullable Class<?> customType) {
         this.entity = entity;
         this.ordinal = ordinal;
         this.id = id;
@@ -91,71 +114,610 @@ public Property(EntityInfo<ENTITY> entity, int ordinal, int id, Class<?> type, S
         this.customType = customType;
     }
 
+    /** Creates an "IS NULL" condition for this property. */
+    public PropertyQueryCondition<ENTITY> isNull() {
+        return new NullCondition<>(this, NullCondition.Operation.IS_NULL);
+    }
+
+    /** Creates an "IS NOT NULL" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notNull() {
+        return new NullCondition<>(this, NullCondition.Operation.NOT_NULL);
+    }
+
+    /** Creates an "equal ('=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> equal(boolean value) {
+        return new LongCondition<>(this, LongCondition.Operation.EQUAL, value);
+    }
+
+    /** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notEqual(boolean value) {
+        return new LongCondition<>(this, LongCondition.Operation.NOT_EQUAL, value);
+    }
+
+    /** Creates an "equal ('=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> equal(short value) {
+        return equal((long) value);
+    }
+
+    /** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notEqual(short value) {
+        return notEqual((long) value);
+    }
+
+    /** Creates a "greater than ('&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greater(short value) {
+        return greater((long) value);
+    }
+
+    /** Creates a "greater or equal ('&gt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(short value) {
+        return greaterOrEqual((long) value);
+    }
+
+    /** Creates a "less than ('&lt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> less(short value) {
+        return less((long) value);
+    }
+
+    /** Creates a "less or equal ('&lt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(short value) {
+        return lessOrEqual((long) value);
+    }
+
+    /**
+     * Creates a "BETWEEN ... AND ..." condition for this property.
+     * Finds objects with property value between and including the first and second value.
+     */
+    public PropertyQueryCondition<ENTITY> between(short lowerBoundary, short upperBoundary) {
+        return between((long) lowerBoundary, upperBoundary);
+    }
+
     /** Creates an "equal ('=')" condition for this property. */
-    public QueryCondition eq(Object value) {
-        return new PropertyCondition(this, Operation.EQUALS, value);
+    public PropertyQueryCondition<ENTITY> equal(int value) {
+        return equal((long) value);
+    }
+
+    /** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notEqual(int value) {
+        return notEqual((long) value);
     }
 
-    /** Creates an "not equal ('&lt;&gt;')" condition for this property. */
-    public QueryCondition notEq(Object value) {
-        return new PropertyCondition(this, Operation.NOT_EQUALS, value);
+    /** Creates a "greater than ('&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greater(int value) {
+        return greater((long) value);
     }
 
-    /** Creates an "BETWEEN ... AND ..." condition for this property. */
-    public QueryCondition between(Object value1, Object value2) {
-        Object[] values = {value1, value2};
-        return new PropertyCondition(this, Operation.BETWEEN, values);
+    /** Creates a "greater or equal ('&gt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(int value) {
+        return greaterOrEqual((long) value);
+    }
+
+    /** Creates a "less than ('&lt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> less(int value) {
+        return less((long) value);
+    }
+
+    /** Creates a "less or equal ('&lt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(int value) {
+        return lessOrEqual((long) value);
+    }
+
+    /**
+     * Creates a "BETWEEN ... AND ..." condition for this property.
+     * Finds objects with property value between and including the first and second value.
+     */
+    public PropertyQueryCondition<ENTITY> between(int lowerBoundary, int upperBoundary) {
+        return between((long) lowerBoundary, upperBoundary);
     }
 
     /** Creates an "IN (..., ..., ...)" condition for this property. */
-    public QueryCondition in(Object... inValues) {
-        return new PropertyCondition(this, Operation.IN, inValues);
+    public PropertyQueryCondition<ENTITY> oneOf(int[] values) {
+        return new IntArrayCondition<>(this, IntArrayCondition.Operation.IN, values);
+    }
+
+    /** Creates a "NOT IN (..., ..., ...)" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notOneOf(int[] values) {
+        return new IntArrayCondition<>(this, IntArrayCondition.Operation.NOT_IN, values);
+    }
+
+    /** Creates an "equal ('=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> equal(long value) {
+        return new LongCondition<>(this, LongCondition.Operation.EQUAL, value);
+    }
+
+    /** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notEqual(long value) {
+        return new LongCondition<>(this, LongCondition.Operation.NOT_EQUAL, value);
+    }
+
+    /** Creates a "greater than ('&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greater(long value) {
+        return new LongCondition<>(this, LongCondition.Operation.GREATER, value);
+    }
+
+    /** Creates a "greater or equal ('&gt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(long value) {
+        return new LongCondition<>(this, LongCondition.Operation.GREATER_OR_EQUAL, value);
+    }
+
+    /** Creates a "less than ('&lt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> less(long value) {
+        return new LongCondition<>(this, LongCondition.Operation.LESS, value);
+    }
+
+    /** Creates a "less or equal ('&lt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(long value) {
+        return new LongCondition<>(this, LongCondition.Operation.LESS_OR_EQUAL, value);
+    }
+
+    /**
+     * Creates a "BETWEEN ... AND ..." condition for this property.
+     * Finds objects with property value between and including the first and second value.
+     */
+    public PropertyQueryCondition<ENTITY> between(long lowerBoundary, long upperBoundary) {
+        return new LongLongCondition<>(this, LongLongCondition.Operation.BETWEEN, lowerBoundary, upperBoundary);
     }
 
     /** Creates an "IN (..., ..., ...)" condition for this property. */
-    public QueryCondition in(Collection<?> inValues) {
-        return in(inValues.toArray());
+    public PropertyQueryCondition<ENTITY> oneOf(long[] values) {
+        return new LongArrayCondition<>(this, LongArrayCondition.Operation.IN, values);
     }
 
-    /** Creates an "greater than ('&gt;')" condition for this property. */
-    public QueryCondition gt(Object value) {
-        return new PropertyCondition(this, Operation.GREATER_THAN, value);
+    /** Creates a "NOT IN (..., ..., ...)" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notOneOf(long[] values) {
+        return new LongArrayCondition<>(this, LongArrayCondition.Operation.NOT_IN, values);
     }
 
-    /** Creates an "less than ('&lt;')" condition for this property. */
-    public QueryCondition lt(Object value) {
-        return new PropertyCondition(this, Operation.LESS_THAN, value);
+    /**
+     * Calls {@link #between(double, double)} with {@code value - tolerance} as lower bound and
+     * {@code value + tolerance} as upper bound.
+     */
+    public PropertyQueryCondition<ENTITY> equal(double value, double tolerance) {
+        return new DoubleDoubleCondition<>(this, DoubleDoubleCondition.Operation.BETWEEN,
+                value - tolerance, value + tolerance);
     }
 
-    /** Creates an "IS NULL" condition for this property. */
-    public QueryCondition isNull() {
-        return new PropertyCondition(this, Operation.IS_NULL, null);
+    /** Creates a "greater than ('&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greater(double value) {
+        return new DoubleCondition<>(this, DoubleCondition.Operation.GREATER, value);
     }
 
-    /** Creates an "IS NOT NULL" condition for this property. */
-    public QueryCondition isNotNull() {
-        return new PropertyCondition(this, Operation.IS_NOT_NULL, null);
+    /** Creates a "greater or equal ('&gt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(double value) {
+        return new DoubleCondition<>(this, DoubleCondition.Operation.GREATER_OR_EQUAL, value);
+    }
+
+    /** Creates a "less than ('&lt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> less(double value) {
+        return new DoubleCondition<>(this, DoubleCondition.Operation.LESS, value);
+    }
+
+    /** Creates a "less or equal ('&lt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(double value) {
+        return new DoubleCondition<>(this, DoubleCondition.Operation.LESS_OR_EQUAL, value);
+    }
+
+    /**
+     * Creates a "BETWEEN ... AND ..." condition for this property.
+     * Finds objects with property value between and including the first and second value.
+     */
+    public PropertyQueryCondition<ENTITY> between(double lowerBoundary, double upperBoundary) {
+        return new DoubleDoubleCondition<>(this, DoubleDoubleCondition.Operation.BETWEEN,
+                lowerBoundary, upperBoundary);
+    }
+
+    /**
+     * Performs an approximate nearest neighbor (ANN) search to find objects near to the given {@code queryVector}.
+     * <p>
+     * This requires the vector property to have an {@link HnswIndex}.
+     * <p>
+     * The dimensions of the query vector should be at least the dimensions of this vector property.
+     * <p>
+     * Use {@code maxResultCount} to set the maximum number of objects to return by the ANN condition. Hint: it can also
+     * be used as the "ef" HNSW parameter to increase the search quality in combination with a query limit. For example,
+     * use maxResultCount of 100 with a Query limit of 10 to have 10 results that are of potentially better quality than
+     * just passing in 10 for maxResultCount (quality/performance tradeoff).
+     * <p>
+     * To change the given parameters after building the query, use {@link Query#setParameter(Property, float[])} and
+     * {@link Query#setParameter(Property, long)} or their alias equivalent.
+     */
+    public PropertyQueryCondition<ENTITY> nearestNeighbors(float[] queryVector, int maxResultCount) {
+        return new NearestNeighborCondition<>(this, queryVector, maxResultCount);
+    }
+
+    /** Creates an "equal ('=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> equal(Date value) {
+        return new LongCondition<>(this, LongCondition.Operation.EQUAL, value);
+    }
+
+    /** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notEqual(Date value) {
+        return new LongCondition<>(this, LongCondition.Operation.NOT_EQUAL, value);
+    }
+
+    /** Creates a "greater than ('&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greater(Date value) {
+        return new LongCondition<>(this, LongCondition.Operation.GREATER, value);
+    }
+
+    /** Creates a "greater or equal ('&gt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(Date value) {
+        return new LongCondition<>(this, LongCondition.Operation.GREATER_OR_EQUAL, value);
+    }
+
+    /** Creates a "less than ('&lt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> less(Date value) {
+        return new LongCondition<>(this, LongCondition.Operation.LESS, value);
+    }
+
+    /** Creates a "less or equal ('&lt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(Date value) {
+        return new LongCondition<>(this, LongCondition.Operation.LESS_OR_EQUAL, value);
+    }
+
+    /** Creates an "IN (..., ..., ...)" condition for this property. */
+    public PropertyQueryCondition<ENTITY> oneOf(Date[] value) {
+        return new LongArrayCondition<>(this, LongArrayCondition.Operation.IN, value);
+    }
+
+    /** Creates a "NOT IN (..., ..., ...)" condition for this property. */
+    public PropertyQueryCondition<ENTITY> notOneOf(Date[] value) {
+        return new LongArrayCondition<>(this, LongArrayCondition.Operation.NOT_IN, value);
+    }
+
+    /**
+     * Creates a "BETWEEN ... AND ..." condition for this property.
+     * Finds objects with property value between and including the first and second value.
+     */
+    public PropertyQueryCondition<ENTITY> between(Date lowerBoundary, Date upperBoundary) {
+        return new LongLongCondition<>(this, LongLongCondition.Operation.BETWEEN, lowerBoundary, upperBoundary);
+    }
+
+    /**
+     * Creates an "equal ('=')" condition for this property
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #equal(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> equal(String value) {
+        return new StringCondition<>(this, StringCondition.Operation.EQUAL, value);
+    }
+
+    /**
+     * Creates an "equal ('=')" condition for this property.
+     */
+    public PropertyQueryCondition<ENTITY> equal(String value, StringOrder order) {
+        return new StringCondition<>(this, StringCondition.Operation.EQUAL, value, order);
+    }
+
+    /**
+     * Creates a "not equal ('&lt;&gt;')" condition for this property
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #notEqual(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> notEqual(String value) {
+        return new StringCondition<>(this, StringCondition.Operation.NOT_EQUAL, value);
+    }
+
+    /**
+     * Creates a "not equal ('&lt;&gt;')" condition for this property.
+     */
+    public PropertyQueryCondition<ENTITY> notEqual(String value, StringOrder order) {
+        return new StringCondition<>(this, StringCondition.Operation.NOT_EQUAL, value, order);
+    }
+
+    /**
+     * Creates a "greater than ('&gt;')" condition for this property
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #greater(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> greater(String value) {
+        return new StringCondition<>(this, StringCondition.Operation.GREATER, value);
+    }
+
+    /**
+     * Creates a "greater than ('&gt;')" condition for this property.
+     */
+    public PropertyQueryCondition<ENTITY> greater(String value, StringOrder order) {
+        return new StringCondition<>(this, StringCondition.Operation.GREATER, value, order);
     }
 
     /**
-     * @see io.objectbox.query.QueryBuilder#contains(Property, String)
+     * Creates a "greater or equal ('&gt;=')" condition for this property.
      */
-    public QueryCondition contains(String value) {
-        return new PropertyCondition(this, Operation.CONTAINS, value);
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(String value, StringOrder order) {
+        return new StringCondition<>(this, StringCondition.Operation.GREATER_OR_EQUAL, value, order);
     }
 
     /**
-     * @see io.objectbox.query.QueryBuilder#startsWith(Property, String)
+     * Creates a "less than ('&lt;')" condition for this property
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #less(String, StringOrder)
      */
-    public QueryCondition startsWith(String value) {
-        return new PropertyCondition(this, Operation.STARTS_WITH, value);
+    public PropertyQueryCondition<ENTITY> less(String value) {
+        return new StringCondition<>(this, StringCondition.Operation.LESS, value);
     }
 
     /**
-     * @see io.objectbox.query.QueryBuilder#endsWith(Property, String)
+     * Creates a "less than ('&lt;')" condition for this property.
      */
-    public QueryCondition endsWith(String value) {
-        return new PropertyCondition(this, Operation.ENDS_WITH, value);
+    public PropertyQueryCondition<ENTITY> less(String value, StringOrder order) {
+        return new StringCondition<>(this, StringCondition.Operation.LESS, value, order);
+    }
+
+    /**
+     * Creates a "less or equal ('&lt;=')" condition for this property.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(String value, StringOrder order) {
+        return new StringCondition<>(this, StringCondition.Operation.LESS_OR_EQUAL, value, order);
+    }
+
+    /**
+     * Creates a contains condition for this property
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     * <p>
+     * Note: for a String array property, use {@link #containsElement} instead.
+     *
+     * @see #contains(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> contains(String value) {
+        checkNotStringArray();
+        return new StringCondition<>(this, StringCondition.Operation.CONTAINS, value);
+    }
+
+    public PropertyQueryCondition<ENTITY> contains(String value, StringOrder order) {
+        checkNotStringArray();
+        return new StringCondition<>(this, StringCondition.Operation.CONTAINS, value, order);
+    }
+
+    private void checkNotStringArray() {
+        if (String[].class == type) {
+            throw new IllegalArgumentException("For a String[] property use containsElement() instead.");
+        }
+    }
+
+    /**
+     * For a String array, list or String-key map property, matches if at least one element equals the given value
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #containsElement(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> containsElement(String value) {
+        return new StringCondition<>(this, Operation.CONTAINS_ELEMENT, value);
+    }
+
+    public PropertyQueryCondition<ENTITY> containsElement(String value, StringOrder order) {
+        return new StringCondition<>(this, Operation.CONTAINS_ELEMENT, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches if at least one key and value combination equals the given values
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @deprecated Use the {@link #equalKeyValue(String, String, StringOrder)} condition instead.
+     *
+     * @see #containsKeyValue(String, String, StringOrder)
+     */
+    @Deprecated
+    public PropertyQueryCondition<ENTITY> containsKeyValue(String key, String value) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.EQUAL_KEY_VALUE,
+                key, value, StringOrder.CASE_SENSITIVE);
+    }
+
+    /**
+     * @deprecated Use the {@link #equalKeyValue(String, String, StringOrder)} condition instead.
+     * @see #containsKeyValue(String, String)
+     */
+    @Deprecated
+    public PropertyQueryCondition<ENTITY> containsKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.EQUAL_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is equal
+     * to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> equalKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.EQUAL_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.GREATER_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterOrEqualKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.GREATER_EQUALS_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.LESS_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqualKeyValue(String key, String value, StringOrder order) {
+        return new StringStringCondition<>(this, StringStringCondition.Operation.LESS_EQUALS_KEY_VALUE,
+                key, value, order);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is equal
+     * to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> equalKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.EQUAL_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.GREATER_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterOrEqualKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.GREATER_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.LESS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqualKeyValue(String key, long value) {
+        return new StringLongCondition<>(this, StringLongCondition.Operation.LESS_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is equal
+     * to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> equalKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.EQUAL_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.GREATER_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is greater
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> greaterOrEqualKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.GREATER_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.LESS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * For a String-key map property, matches the combination where the key and value of at least one map entry is less
+     * than or equal to the given {@code key} and {@code value}.
+     */
+    public PropertyQueryCondition<ENTITY> lessOrEqualKeyValue(String key, double value) {
+        return new StringDoubleCondition<>(this, StringDoubleCondition.Operation.LESS_EQUALS_KEY_VALUE,
+                key, value);
+    }
+
+    /**
+     * Creates a starts with condition using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #startsWith(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> startsWith(String value) {
+        return new StringCondition<>(this, Operation.STARTS_WITH, value);
+    }
+
+    public PropertyQueryCondition<ENTITY> startsWith(String value, StringOrder order) {
+        return new StringCondition<>(this, Operation.STARTS_WITH, value, order);
+    }
+
+    /**
+     * Creates an ends with condition using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #endsWith(String, StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> endsWith(String value) {
+        return new StringCondition<>(this, Operation.ENDS_WITH, value);
+    }
+
+    public PropertyQueryCondition<ENTITY> endsWith(String value, StringOrder order) {
+        return new StringCondition<>(this, Operation.ENDS_WITH, value, order);
+    }
+
+    /**
+     * Creates an "IN (..., ..., ...)" condition for this property
+     * using {@link StringOrder#CASE_SENSITIVE StringOrder#CASE_SENSITIVE}.
+     *
+     * @see #oneOf(String[], StringOrder)
+     */
+    public PropertyQueryCondition<ENTITY> oneOf(String[] values) {
+        return new StringArrayCondition<>(this, StringArrayCondition.Operation.IN, values);
+    }
+
+    /**
+     * Creates an "IN (..., ..., ...)" condition for this property.
+     */
+    public PropertyQueryCondition<ENTITY> oneOf(String[] values, StringOrder order) {
+        return new StringArrayCondition<>(this, StringArrayCondition.Operation.IN, values, order);
+    }
+
+    /** Creates an "equal ('=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> equal(byte[] value) {
+        return new ByteArrayCondition<>(this, ByteArrayCondition.Operation.EQUAL, value);
+    }
+
+    /** Creates a "greater than ('&gt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greater(byte[] value) {
+        return new ByteArrayCondition<>(this, ByteArrayCondition.Operation.GREATER, value);
+    }
+
+    /** Creates a "greater or equal ('&gt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> greaterOrEqual(byte[] value) {
+        return new ByteArrayCondition<>(this, ByteArrayCondition.Operation.GREATER_OR_EQUAL, value);
+    }
+
+    /** Creates a "less than ('&lt;')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> less(byte[] value) {
+        return new ByteArrayCondition<>(this, ByteArrayCondition.Operation.LESS, value);
+    }
+
+    /** Creates a "less or equal ('&lt;=')" condition for this property. */
+    public PropertyQueryCondition<ENTITY> lessOrEqual(byte[] value) {
+        return new ByteArrayCondition<>(this, ByteArrayCondition.Operation.LESS_OR_EQUAL, value);
     }
 
     @Internal
@@ -166,7 +728,7 @@ public int getEntityId() {
     @Internal
     public int getId() {
         if (this.id <= 0) {
-            throw new IllegalStateException("Illegal property ID " + id + " for " + toString());
+            throw new IllegalStateException("Illegal property ID " + id + " for " + this);
         }
         return id;
     }
@@ -177,10 +739,10 @@ boolean isIdVerified() {
 
     void verifyId(int idInDb) {
         if (this.id <= 0) {
-            throw new IllegalStateException("Illegal property ID " + id + " for " + toString());
+            throw new IllegalStateException("Illegal property ID " + id + " for " + this);
         }
         if (this.id != idInDb) {
-            throw new DbException(toString() + " does not match ID in DB: " + idInDb);
+            throw new DbException(this + " does not match ID in DB: " + idInDb);
         }
         idVerified = true;
     }
diff --git a/objectbox-java/src/main/java/io/objectbox/Transaction.java b/objectbox-java/src/main/java/io/objectbox/Transaction.java
index 888317cb..323cd2c2 100644
--- a/objectbox-java/src/main/java/io/objectbox/Transaction.java
+++ b/objectbox-java/src/main/java/io/objectbox/Transaction.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
 
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.exception.DbException;
 import io.objectbox.internal.CursorFactory;
 
 @Internal
@@ -87,7 +88,7 @@ protected void finalize() throws Throwable {
         super.finalize();
     }
 
-    private void checkOpen() {
+    void checkOpen() {
         if (closed) {
             throw new IllegalStateException("Transaction is closed");
         }
@@ -100,7 +101,9 @@ public synchronized void close() {
             closed = true;
             store.unregisterTransaction(this);
 
-            if (!nativeIsOwnerThread(transaction)) {
+            boolean isOwnerThread = nativeIsOwnerThread(transaction);
+            if (!isOwnerThread) {
+                // Note: don't use isActive(), it returns false here because closed == true already
                 boolean isActive = nativeIsActive(transaction);
                 boolean isRecycled = nativeIsRecycled(transaction);
                 if (isActive || isRecycled) {
@@ -123,12 +126,51 @@ public synchronized void close() {
 
             // If store is already closed natively, destroying the tx would cause EXCEPTION_ACCESS_VIOLATION
             // TODO not destroying is probably only a small leak on rare occasions, but still could be fixed
-            if (!store.isClosed()) {
+            if (!store.isNativeStoreClosed()) {
                 nativeDestroy(transaction);
+            } else {
+                // Note: don't use isActive(), it returns false here because closed == true already
+                boolean isActive = nativeIsActive(transaction);
+                if (readOnly) {
+                    // Minor leak if TX is active, but still log so the ObjectBox team can check that it only happens
+                    // occasionally.
+                    // Note this cannot assume the store isn't destroyed, yet. The native and Java stores may at best
+                    // briefly wait for read transactions.
+                    System.out.printf(
+                            "Info: closing read transaction after store was closed (isActive=%s, isOwnerThread=%s), this should be avoided.%n",
+                            isActive, isOwnerThread);
+                    System.out.flush();
+
+                    // Note: get fresh active state
+                    if (!nativeIsActive(transaction)) {
+                        nativeDestroy(transaction);
+                    }
+                } else {
+                    // write transaction
+                    System.out.printf(
+                            "WARN: closing write transaction after store was closed (isActive=%s, isOwnerThread=%s), this must be avoided.%n",
+                            isActive, isOwnerThread);
+                    System.out.flush();
+
+                    // Note: get fresh active state
+                    if (nativeIsActive(transaction) && store.isNativeStoreDestroyed()) {
+                        // This is an internal validation: if this is an active write-TX,
+                        // the (native) store will always wait for it, so it must not be destroyed yet.
+                        // If this ever happens, the above assumption is wrong, and throwing likely prevents a SIGSEGV.
+                        throw new IllegalStateException(
+                                "Internal error: cannot close active write transaction for an already destroyed store");
+                    }
+                    // Note: inactive transactions are always safe to destroy, regardless of store state and thread.
+                    // Note: the current native impl panics if the transaction is active AND created in another thread.
+                    nativeDestroy(transaction);
+                }
             }
         }
     }
 
+    /**
+     * For a write transaction commits the changes. For a read transaction throws.
+     */
     public void commit() {
         checkOpen();
         int[] entityTypeIdsAffected = nativeCommit(transaction);
@@ -140,6 +182,9 @@ public void commitAndClose() {
         close();
     }
 
+    /**
+     * For a read or write transaction, aborts it.
+     */
     public void abort() {
         checkOpen();
         nativeAbort(transaction);
@@ -183,6 +228,7 @@ public <T> Cursor<T> createCursor(Class<T> entityClass) {
         EntityInfo<T> entityInfo = store.getEntityInfo(entityClass);
         CursorFactory<T> factory = entityInfo.getCursorFactory();
         long cursorHandle = nativeCreateCursor(transaction, entityInfo.getDbName(), entityClass);
+        if (cursorHandle == 0) throw new DbException("Could not create native cursor");
         return factory.createCursor(this, cursorHandle, store);
     }
 
@@ -190,9 +236,14 @@ public BoxStore getStore() {
         return store;
     }
 
+    /**
+     * A transaction is active after it was created until {@link #close()}, {@link #abort()}, or, for write
+     * transactions only, {@link #commit()} is called.
+     *
+     * @return If this transaction is active.
+     */
     public boolean isActive() {
-        checkOpen();
-        return nativeIsActive(transaction);
+        return !closed && nativeIsActive(transaction);
     }
 
     public boolean isRecycled() {
diff --git a/objectbox-java/src/main/java/io/objectbox/TxCallback.java b/objectbox-java/src/main/java/io/objectbox/TxCallback.java
index 9e9b216a..281c7c2f 100644
--- a/objectbox-java/src/main/java/io/objectbox/TxCallback.java
+++ b/objectbox-java/src/main/java/io/objectbox/TxCallback.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/config/DebugFlags.java b/objectbox-java/src/main/java/io/objectbox/config/DebugFlags.java
new file mode 100644
index 00000000..68e9de10
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/DebugFlags.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * Debug flags typically enable additional "debug logging" that can be helpful to better understand what is going on
+ * internally. These are intended for the development process only; typically one does not enable them for releases.
+ */
+@SuppressWarnings("unused")
+public final class DebugFlags {
+  private DebugFlags() { }
+  public static final int LOG_TRANSACTIONS_READ = 1;
+  public static final int LOG_TRANSACTIONS_WRITE = 2;
+  public static final int LOG_QUERIES = 4;
+  public static final int LOG_QUERY_PARAMETERS = 8;
+  public static final int LOG_ASYNC_QUEUE = 16;
+  public static final int LOG_CACHE_HITS = 32;
+  public static final int LOG_CACHE_ALL = 64;
+  public static final int LOG_TREE = 128;
+  /**
+   * For a limited number of error conditions, this will try to print stack traces.
+   * Note: this is Linux-only, experimental, and has several limitations:
+   * The usefulness of these stack traces depends on several factors and might not be helpful at all.
+   */
+  public static final int LOG_EXCEPTION_STACK_TRACE = 256;
+  /**
+   * Run a quick self-test to verify basic threading; somewhat paranoia to check the platform and the library setup.
+   */
+  public static final int RUN_THREADING_SELF_TEST = 512;
+  /**
+   * Enables debug logs for write-ahead logging
+   */
+  public static final int LOG_WAL = 1024;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java b/objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java
new file mode 100644
index 00000000..94187b2d
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/FlatStoreOptions.java
@@ -0,0 +1,269 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Options to open a store with. Set only the values you want; defaults are used otherwise.
+ * Reminder: enable "force defaults" in the FlatBuffers builder, e.g. to pass in booleans with value "false".
+ * NOTE: some setting are for "advanced" purposes that you can typically ignore for regular usage.
+ *       When using advanced setting, you should know exactly what you are doing.
+ */
+@SuppressWarnings("unused")
+public final class FlatStoreOptions extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static FlatStoreOptions getRootAsFlatStoreOptions(ByteBuffer _bb) { return getRootAsFlatStoreOptions(_bb, new FlatStoreOptions()); }
+  public static FlatStoreOptions getRootAsFlatStoreOptions(ByteBuffer _bb, FlatStoreOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public FlatStoreOptions __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * Location of the database on disk; this will be a directory containing files.
+   */
+  public String directoryPath() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer directoryPathAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public ByteBuffer directoryPathInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+  /**
+   * Provide a data model, e.g. to initialize or update the schema.
+   */
+  public int modelBytes(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int modelBytesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public ByteVector modelBytesVector() { return modelBytesVector(new ByteVector()); }
+  public ByteVector modelBytesVector(ByteVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer modelBytesAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+  public ByteBuffer modelBytesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
+  /**
+   * This maximum size setting is meant to prevent your database from growing to unexpected sizes,
+   * e.g. caused by programming error.
+   * If your app runs into errors like "db full", you may consider to raise the limit.
+   */
+  public long maxDbSizeInKbyte() { int o = __offset(8); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * File permissions given in Unix style octal bit flags (e.g. 0644). Ignored on Windows.
+   * Note: directories become searchable if the "read" or "write" permission is set (e.g. 0640 becomes 0750).
+   */
+  public long fileMode() { int o = __offset(10); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The maximum number of readers (related to read transactions).
+   * "Readers" are an finite resource for which we need to define a maximum number upfront.
+   * The default value is enough for most apps and usually you can ignore it completely.
+   * However, if you get the OBX_ERROR_MAX_READERS_EXCEEDED error, you should verify your
+   * threading. For each thread, ObjectBox uses multiple readers. Their number (per thread) depends
+   * on number of types, relations, and usage patterns. Thus, if you are working with many threads
+   * (e.g. in a server-like scenario), it can make sense to increase the maximum number of readers.
+   *
+   * Note: The internal default is currently 126. So when hitting this limit, try value s around 200-500.
+   *
+   * Note: Each thread that performed a read transaction and is still alive holds on to a reader slot.
+   *       These slots only get vacated when the thread ends. Thus be mindful with the number of active threads.
+   *       Alternatively, you can opt to try the experimental noReaderThreadLocals option flag.
+   */
+  public long maxReaders() { int o = __offset(12); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+   * Reliable file systems already guarantee consistency, so this is primarily meant to deal with unreliable
+   * OSes, file systems, or hardware.
+   * Note: ObjectBox builds upon ACID storage, which already has strong consistency mechanisms in place.
+   */
+  public int validateOnOpenPages() { int o = __offset(14); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * To fine-tune database validation, you can specify a limit on how much data is looked at.
+   * This is measured in "pages" with a page typically holding 4K.
+   * Usually a low number (e.g. 1-20) is sufficient and does not impact startup performance significantly.
+   * This is only to be used with ValidateOnOpenMode "Regular" and "WithLeaves".
+   */
+  public long validateOnOpenPageLimit() { int o = __offset(16); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * Don't touch unless you know exactly what you are doing:
+   * Advanced setting typically meant for language bindings (not end users). See PutPaddingMode description.
+   */
+  public int putPaddingMode() { int o = __offset(18); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Advanced setting meant only for special scenarios: opens the database in a limited, schema-less mode.
+   * If you don't know what this means exactly: ignore this flag.
+   */
+  public boolean skipReadSchema() { int o = __offset(20); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  /**
+   * Advanced setting recommended to be used together with read-only mode to ensure no data is lost.
+   * Ignores the latest data snapshot (committed transaction state) and uses the previous snapshot instead.
+   * When used with care (e.g. backup the DB files first), this option may also recover data removed by the latest
+   * transaction.
+   */
+  public boolean usePreviousCommit() { int o = __offset(22); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  /**
+   * NOT IMPLEMENTED YET. Placeholder for a future version only.
+   * If consistency checks fail during opening the DB (see also the pagesToValidateOnOpen setting), ObjectBox
+   * automatically switches to the previous commit (see also usePreviousCommit). This way, this constitutes
+   * an auto-recover mode from severe failures. HOWEVER, keep in mind that any consistency failure
+   * is an indication that something is very wrong with OS/hardware and thus you should also check
+   * openedWithPreviousCommit(), e.g. to alert your users.
+   */
+  public boolean usePreviousCommitOnValidationFailure() { int o = __offset(24); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  /**
+   * Open store in read-only mode: no schema update, no write transactions.
+   */
+  public boolean readOnly() { int o = __offset(26); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  /**
+   * For debugging purposes you may want enable specific logging.
+   */
+  public long debugFlags() { int o = __offset(28); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Disables the usage of thread locals for "readers" related to read transactions.
+   * This can make sense if you are using a lot of threads that are kept alive.
+   *
+   * Note: This is still experimental, as it comes with subtle behavior changes at a low level and may affect
+   *       corner cases with e.g. transactions, which may not be fully tested at the moment.
+   */
+  public boolean noReaderThreadLocals() { int o = __offset(30); return o != 0 ? 0!=bb.get(o + bb_pos) : false; }
+  /**
+   * Data size tracking is more involved than DB size tracking, e.g. it stores an internal counter.
+   * Thus only use it if a stricter, more accurate limit is required.
+   * It tracks the size of actual data bytes of objects (system and metadata is not considered).
+   * On the upside, reaching the data limit still allows data to be removed (assuming DB limit is not reached).
+   * Max data and DB sizes can be combined; data size must be below the DB size.
+   */
+  public long maxDataSizeInKbyte() { int o = __offset(32); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * When a database is opened, ObjectBox can perform additional consistency checks on its database structure.
+   * This enum is used to enable validation checks on a key/value level.
+   */
+  public int validateOnOpenKv() { int o = __offset(34); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Restores the database content from the given backup file (note: backup is a server-only feature).
+   * By default, actually restoring the backup is only performed if no database already exists
+   * (database does not contain data).
+   * This behavior can be adjusted with backupRestoreFlags, e.g., to overwrite all existing data in the database.
+   *
+   * \note Backup files are created from an existing database using ObjectBox API.
+   *
+   * \note The following error types can occur for different error scenarios:
+   *       * IO error: the backup file doesn't exist, couldn't be read or has an unexpected size,
+   *       * format error: the backup-file is malformed
+   *       * integrity error: the backup file failed integrity checks
+   */
+  public String backupFile() { int o = __offset(36); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer backupFileAsByteBuffer() { return __vector_as_bytebuffer(36, 1); }
+  public ByteBuffer backupFileInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 36, 1); }
+  /**
+   * Flags to change the default behavior for restoring backups, e.g. what should happen to existing data.
+   */
+  public long backupRestoreFlags() { int o = __offset(38); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Options for write-ahead logging (WAL)
+   */
+  public WalOptions walOptions() { return walOptions(new WalOptions()); }
+  public WalOptions walOptions(WalOptions obj) { int o = __offset(40); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+
+  public static int createFlatStoreOptions(FlatBufferBuilder builder,
+      int directoryPathOffset,
+      int modelBytesOffset,
+      long maxDbSizeInKbyte,
+      long fileMode,
+      long maxReaders,
+      int validateOnOpenPages,
+      long validateOnOpenPageLimit,
+      int putPaddingMode,
+      boolean skipReadSchema,
+      boolean usePreviousCommit,
+      boolean usePreviousCommitOnValidationFailure,
+      boolean readOnly,
+      long debugFlags,
+      boolean noReaderThreadLocals,
+      long maxDataSizeInKbyte,
+      int validateOnOpenKv,
+      int backupFileOffset,
+      long backupRestoreFlags,
+      int walOptionsOffset) {
+    builder.startTable(19);
+    FlatStoreOptions.addMaxDataSizeInKbyte(builder, maxDataSizeInKbyte);
+    FlatStoreOptions.addValidateOnOpenPageLimit(builder, validateOnOpenPageLimit);
+    FlatStoreOptions.addMaxDbSizeInKbyte(builder, maxDbSizeInKbyte);
+    FlatStoreOptions.addWalOptions(builder, walOptionsOffset);
+    FlatStoreOptions.addBackupRestoreFlags(builder, backupRestoreFlags);
+    FlatStoreOptions.addBackupFile(builder, backupFileOffset);
+    FlatStoreOptions.addDebugFlags(builder, debugFlags);
+    FlatStoreOptions.addMaxReaders(builder, maxReaders);
+    FlatStoreOptions.addFileMode(builder, fileMode);
+    FlatStoreOptions.addModelBytes(builder, modelBytesOffset);
+    FlatStoreOptions.addDirectoryPath(builder, directoryPathOffset);
+    FlatStoreOptions.addValidateOnOpenKv(builder, validateOnOpenKv);
+    FlatStoreOptions.addPutPaddingMode(builder, putPaddingMode);
+    FlatStoreOptions.addValidateOnOpenPages(builder, validateOnOpenPages);
+    FlatStoreOptions.addNoReaderThreadLocals(builder, noReaderThreadLocals);
+    FlatStoreOptions.addReadOnly(builder, readOnly);
+    FlatStoreOptions.addUsePreviousCommitOnValidationFailure(builder, usePreviousCommitOnValidationFailure);
+    FlatStoreOptions.addUsePreviousCommit(builder, usePreviousCommit);
+    FlatStoreOptions.addSkipReadSchema(builder, skipReadSchema);
+    return FlatStoreOptions.endFlatStoreOptions(builder);
+  }
+
+  public static void startFlatStoreOptions(FlatBufferBuilder builder) { builder.startTable(19); }
+  public static void addDirectoryPath(FlatBufferBuilder builder, int directoryPathOffset) { builder.addOffset(0, directoryPathOffset, 0); }
+  public static void addModelBytes(FlatBufferBuilder builder, int modelBytesOffset) { builder.addOffset(1, modelBytesOffset, 0); }
+  public static int createModelBytesVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+  public static int createModelBytesVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
+  public static void startModelBytesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static void addMaxDbSizeInKbyte(FlatBufferBuilder builder, long maxDbSizeInKbyte) { builder.addLong(2, maxDbSizeInKbyte, 0L); }
+  public static void addFileMode(FlatBufferBuilder builder, long fileMode) { builder.addInt(3, (int) fileMode, (int) 0L); }
+  public static void addMaxReaders(FlatBufferBuilder builder, long maxReaders) { builder.addInt(4, (int) maxReaders, (int) 0L); }
+  public static void addValidateOnOpenPages(FlatBufferBuilder builder, int validateOnOpenPages) { builder.addShort(5, (short) validateOnOpenPages, (short) 0); }
+  public static void addValidateOnOpenPageLimit(FlatBufferBuilder builder, long validateOnOpenPageLimit) { builder.addLong(6, validateOnOpenPageLimit, 0L); }
+  public static void addPutPaddingMode(FlatBufferBuilder builder, int putPaddingMode) { builder.addShort(7, (short) putPaddingMode, (short) 0); }
+  public static void addSkipReadSchema(FlatBufferBuilder builder, boolean skipReadSchema) { builder.addBoolean(8, skipReadSchema, false); }
+  public static void addUsePreviousCommit(FlatBufferBuilder builder, boolean usePreviousCommit) { builder.addBoolean(9, usePreviousCommit, false); }
+  public static void addUsePreviousCommitOnValidationFailure(FlatBufferBuilder builder, boolean usePreviousCommitOnValidationFailure) { builder.addBoolean(10, usePreviousCommitOnValidationFailure, false); }
+  public static void addReadOnly(FlatBufferBuilder builder, boolean readOnly) { builder.addBoolean(11, readOnly, false); }
+  public static void addDebugFlags(FlatBufferBuilder builder, long debugFlags) { builder.addInt(12, (int) debugFlags, (int) 0L); }
+  public static void addNoReaderThreadLocals(FlatBufferBuilder builder, boolean noReaderThreadLocals) { builder.addBoolean(13, noReaderThreadLocals, false); }
+  public static void addMaxDataSizeInKbyte(FlatBufferBuilder builder, long maxDataSizeInKbyte) { builder.addLong(14, maxDataSizeInKbyte, 0L); }
+  public static void addValidateOnOpenKv(FlatBufferBuilder builder, int validateOnOpenKv) { builder.addShort(15, (short) validateOnOpenKv, (short) 0); }
+  public static void addBackupFile(FlatBufferBuilder builder, int backupFileOffset) { builder.addOffset(16, backupFileOffset, 0); }
+  public static void addBackupRestoreFlags(FlatBufferBuilder builder, long backupRestoreFlags) { builder.addInt(17, (int) backupRestoreFlags, (int) 0L); }
+  public static void addWalOptions(FlatBufferBuilder builder, int walOptionsOffset) { builder.addOffset(18, walOptionsOffset, 0); }
+  public static int endFlatStoreOptions(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+  public static void finishFlatStoreOptionsBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); }
+  public static void finishSizePrefixedFlatStoreOptionsBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset); }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public FlatStoreOptions get(int j) { return get(new FlatStoreOptions(), j); }
+    public FlatStoreOptions get(FlatStoreOptions obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/config/TreeOptionFlags.java b/objectbox-java/src/main/java/io/objectbox/config/TreeOptionFlags.java
new file mode 100644
index 00000000..5b2bee91
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/TreeOptionFlags.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * Options flags for trees.
+ */
+@SuppressWarnings("unused")
+public final class TreeOptionFlags {
+  private TreeOptionFlags() { }
+  /**
+   * If true, debug logs are always disabled for this tree regardless of the store's debug flags.
+   */
+  public static final int DebugLogsDisable = 1;
+  /**
+   * If true, debug logs are always enabled for this tree regardless of the store's debug flags.
+   */
+  public static final int DebugLogsEnable = 2;
+  /**
+   * By default, a path such as "a/b/c" can address a branch and a leaf at the same time.
+   * E.g. under the common parent path "a/b", a branch "c" and a "c" leaf may exist.
+   * To disable this, set this flag to true.
+   * This will enable an additional check when inserting new leafs and new branches for the existence of the other.
+   */
+  public static final int EnforceUniquePath = 4;
+  /**
+   * In some scenarios, e.g. when using Sync, multiple node objects of the same type (e.g. branch or leaf) at the
+   * same path may exist temporarily. By enabling this flag, this is not considered an error situation. Instead, the
+   * first node is picked.
+   */
+  public static final int AllowNonUniqueNodes = 8;
+  /**
+   * Nodes described in AllowNonUniqueNodes will be automatically detected to consolidate them (manually).
+   */
+  public static final int DetectNonUniqueNodes = 16;
+  /**
+   * Nodes described in AllowNonUniqueNodes will be automatically consolidated to make them unique.
+   * This consolidation happens e.g. on put/remove operations.
+   * Using this value implies DetectNonUniqueNodes.
+   */
+  public static final int AutoConsolidateNonUniqueNodes = 32;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModeKv.java b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModeKv.java
new file mode 100644
index 00000000..9ff9a989
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModeKv.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * Defines if and how the database is checked for valid key/value (KV) entries when opening it.
+ */
+@SuppressWarnings("unused")
+public final class ValidateOnOpenModeKv {
+  private ValidateOnOpenModeKv() { }
+  /**
+   * Not a real type, just best practice (e.g. forward compatibility).
+   */
+  public static final short Unknown = 0;
+  /**
+   * Performs standard checks.
+   */
+  public static final short Regular = 1;
+
+  public static final String[] names = { "Unknown", "Regular", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModePages.java b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModePages.java
new file mode 100644
index 00000000..6f191104
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/ValidateOnOpenModePages.java
@@ -0,0 +1,56 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+/**
+ * Defines if and how the database is checked for structural consistency (pages) when opening it.
+ */
+@SuppressWarnings("unused")
+public final class ValidateOnOpenModePages {
+  private ValidateOnOpenModePages() { }
+  /**
+   * Not a real type, just best practice (e.g. forward compatibility)
+   */
+  public static final short Unknown = 0;
+  /**
+   * No additional checks are performed. This is fine if your file system is reliable (which it typically should be).
+   */
+  public static final short None = 1;
+  /**
+   * Performs a limited number of checks on the most important database structures (e.g. "branch pages").
+   */
+  public static final short Regular = 2;
+  /**
+   * Performs a limited number of checks on database structures including "data leaves".
+   */
+  public static final short WithLeaves = 3;
+  /**
+   * Performs a unlimited number of checks on the most important database structures (e.g. "branch pages").
+   */
+  public static final short AllBranches = 4;
+  /**
+   * Performs a unlimited number of checks on database structures including "data leaves".
+   */
+  public static final short Full = 5;
+
+  public static final String[] names = { "Unknown", "None", "Regular", "WithLeaves", "AllBranches", "Full", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/DebugFlags.java b/objectbox-java/src/main/java/io/objectbox/config/WalFlags.java
similarity index 54%
rename from objectbox-java/src/main/java/io/objectbox/DebugFlags.java
rename to objectbox-java/src/main/java/io/objectbox/config/WalFlags.java
index ebd95bd0..c867a299 100644
--- a/objectbox-java/src/main/java/io/objectbox/DebugFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/config/WalFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,19 +16,21 @@
 
 // automatically generated by the FlatBuffers compiler, do not modify
 
-package io.objectbox;
+package io.objectbox.config;
 
 /**
- * Not really an enum, but binary flags to use across languages
+ * WAL flags control how the store handles WAL files.
  */
-public final class DebugFlags {
-  private DebugFlags() { }
-  public static final int LOG_TRANSACTIONS_READ = 1;
-  public static final int LOG_TRANSACTIONS_WRITE = 2;
-  public static final int LOG_QUERIES = 4;
-  public static final int LOG_QUERY_PARAMETERS = 8;
-  public static final int LOG_ASYNC_QUEUE = 16;
-  public static final int LOG_CACHE_HITS = 32;
-  public static final int LOG_CACHE_ALL = 64;
+@SuppressWarnings("unused")
+public final class WalFlags {
+  private WalFlags() { }
+  /**
+   * Enable WAL
+   */
+  public static final int EnableWal = 1;
+  /**
+   * Does not wait for the disk to acknowledge
+   */
+  public static final int NoFileSync = 2;
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/config/WalOptions.java b/objectbox-java/src/main/java/io/objectbox/config/WalOptions.java
new file mode 100644
index 00000000..ce637943
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/config/WalOptions.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.config;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.Table;
+
+/**
+ * Options to enable and configure WAL.
+ */
+@SuppressWarnings("unused")
+public final class WalOptions extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static WalOptions getRootAsWalOptions(ByteBuffer _bb) { return getRootAsWalOptions(_bb, new WalOptions()); }
+  public static WalOptions getRootAsWalOptions(ByteBuffer _bb, WalOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public WalOptions __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * Flags to enable and change default WAL behavior, e.g. no sync to disk option.
+   */
+  public long walFlags() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The WAL file gets consolidated when it reached this size limit when opening the database.
+   * This setting is meant for applications that prefer to consolidate on startup,
+   * which may avoid consolidations on commits while the application is running.
+   * The default is 4096 (4 MB).
+   */
+  public long maxWalFileSizeOnOpenInKbyte() { int o = __offset(6); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * The WAL file gets consolidated when it reaches this size limit after a commit.
+   * As consolidation takes some time, it is a trade-off between accumulating enough data
+   * and the time the consolidation takes (longer with more data).
+   * The default is 16384 (16 MB).
+   */
+  public long maxWalFileSizeInKbyte() { int o = __offset(8); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+
+  public static int createWalOptions(FlatBufferBuilder builder,
+      long walFlags,
+      long maxWalFileSizeOnOpenInKbyte,
+      long maxWalFileSizeInKbyte) {
+    builder.startTable(3);
+    WalOptions.addMaxWalFileSizeInKbyte(builder, maxWalFileSizeInKbyte);
+    WalOptions.addMaxWalFileSizeOnOpenInKbyte(builder, maxWalFileSizeOnOpenInKbyte);
+    WalOptions.addWalFlags(builder, walFlags);
+    return WalOptions.endWalOptions(builder);
+  }
+
+  public static void startWalOptions(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void addWalFlags(FlatBufferBuilder builder, long walFlags) { builder.addInt(0, (int) walFlags, (int) 0L); }
+  public static void addMaxWalFileSizeOnOpenInKbyte(FlatBufferBuilder builder, long maxWalFileSizeOnOpenInKbyte) { builder.addLong(1, maxWalFileSizeOnOpenInKbyte, 0L); }
+  public static void addMaxWalFileSizeInKbyte(FlatBufferBuilder builder, long maxWalFileSizeInKbyte) { builder.addLong(2, maxWalFileSizeInKbyte, 0L); }
+  public static int endWalOptions(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public WalOptions get(int j) { return get(new WalOptions(), j); }
+    public WalOptions get(WalOptions obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java
new file mode 100644
index 00000000..45c3f363
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/FlexObjectConverter.java
@@ -0,0 +1,354 @@
+/*
+ * Copyright 2021-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import java.lang.reflect.Field;
+import java.nio.ByteBuffer;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+
+import io.objectbox.flatbuffers.ArrayReadWriteBuf;
+import io.objectbox.flatbuffers.FlexBuffers;
+import io.objectbox.flatbuffers.FlexBuffersBuilder;
+
+/**
+ * Converts between {@link Object} properties and byte arrays using FlexBuffers.
+ * <p>
+ * Types are limited to those supported by FlexBuffers, including that map keys must be {@link String}.
+ * (There are subclasses available that auto-convert {@link Integer} and {@link Long} key maps,
+ * see {@link #convertToKey}.)
+ * <p>
+ * If any item requires 64 bits for storage in the FlexBuffers Map/Vector (a large Long, a Double)
+ * all integers are restored as {@link Long}, otherwise {@link Integer}.
+ * So e.g. when storing only a {@link Long} value of {@code 1L}, the value restored from the
+ * database will be of type {@link Integer}.
+ * (There are subclasses available that always restore as {@link Long}, see {@link #shouldRestoreAsLong}.)
+ * <p>
+ * Values of type {@link Float} are always restored as {@link Double}.
+ * Cast to {@link Float} to obtain the original value.
+ */
+public class FlexObjectConverter implements PropertyConverter<Object, byte[]> {
+
+    private static final AtomicReference<FlexBuffersBuilder> cachedBuilder = new AtomicReference<>();
+
+    @Override
+    public byte[] convertToDatabaseValue(Object value) {
+        if (value == null) return null;
+
+        FlexBuffersBuilder builder = cachedBuilder.getAndSet(null);
+        if (builder == null) {
+            // Note: BUILDER_FLAG_SHARE_KEYS_AND_STRINGS is as fast as no flags for small maps/strings
+            // and faster for larger maps/strings. BUILDER_FLAG_SHARE_STRINGS is always slower.
+            builder = new FlexBuffersBuilder(
+                    new ArrayReadWriteBuf(512),
+                    FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS
+            );
+        }
+
+        addValue(builder, value);
+
+        ByteBuffer buffer = builder.finish();
+
+        byte[] out = new byte[buffer.limit()];
+        buffer.get(out);
+
+        // Cache if builder does not consume too much memory
+        if (buffer.limit() <= 256 * 1024) {
+            builder.clear();
+            cachedBuilder.getAndSet(builder);
+        }
+
+        return out;
+    }
+
+    private void addValue(FlexBuffersBuilder builder, Object value) {
+        if (value instanceof Map) {
+            //noinspection unchecked
+            addMap(builder, null, (Map<Object, Object>) value);
+        } else if (value instanceof List) {
+            //noinspection unchecked
+            addVector(builder, null, (List<Object>) value);
+        } else if (value instanceof String) {
+            builder.putString((String) value);
+        } else if (value instanceof Boolean) {
+            builder.putBoolean((Boolean) value);
+        } else if (value instanceof Byte) {
+            // Will always be restored as Integer.
+            builder.putInt(((Byte) value).intValue());
+        } else if (value instanceof Short) {
+            // Will always be restored as Integer.
+            builder.putInt(((Short) value).intValue());
+        } else if (value instanceof Integer) {
+            builder.putInt((Integer) value);
+        } else if (value instanceof Long) {
+            builder.putInt((Long) value);
+        } else if (value instanceof Float) {
+            builder.putFloat((Float) value);
+        } else if (value instanceof Double) {
+            builder.putFloat((Double) value);
+        } else if (value instanceof byte[]) {
+            builder.putBlob((byte[]) value);
+        } else {
+            throw new IllegalArgumentException(
+                    "Values of this type are not supported: " + value.getClass().getSimpleName());
+        }
+    }
+
+    /**
+     * Checks Java map key is of the expected type, otherwise throws.
+     */
+    protected void checkMapKeyType(Object rawKey) {
+        if (!(rawKey instanceof String)) {
+            throw new IllegalArgumentException("Map keys must be String");
+        }
+    }
+
+    private void addMap(FlexBuffersBuilder builder, String mapKey, Map<Object, Object> map) {
+        int mapStart = builder.startMap();
+
+        for (Map.Entry<Object, Object> entry : map.entrySet()) {
+            Object rawKey = entry.getKey();
+            Object value = entry.getValue();
+            if (rawKey == null) {
+                throw new IllegalArgumentException("Map keys must not be null");
+            }
+            checkMapKeyType(rawKey);
+            String key = rawKey.toString();
+            if (value == null) {
+                builder.putNull(key);
+            } else if (value instanceof Map) {
+                //noinspection unchecked
+                addMap(builder, key, (Map<Object, Object>) value);
+            } else if (value instanceof List) {
+                //noinspection unchecked
+                addVector(builder, key, (List<Object>) value);
+            } else if (value instanceof String) {
+                builder.putString(key, (String) value);
+            } else if (value instanceof Boolean) {
+                builder.putBoolean(key, (Boolean) value);
+            } else if (value instanceof Byte) {
+                // Will always be restored as Integer.
+                builder.putInt(key, ((Byte) value).intValue());
+            } else if (value instanceof Short) {
+                // Will always be restored as Integer.
+                builder.putInt(key, ((Short) value).intValue());
+            } else if (value instanceof Integer) {
+                builder.putInt(key, (Integer) value);
+            } else if (value instanceof Long) {
+                builder.putInt(key, (Long) value);
+            } else if (value instanceof Float) {
+                builder.putFloat(key, (Float) value);
+            } else if (value instanceof Double) {
+                builder.putFloat(key, (Double) value);
+            } else if (value instanceof byte[]) {
+                builder.putBlob(key, (byte[]) value);
+            } else {
+                throw new IllegalArgumentException(
+                        "Map values of this type are not supported: " + value.getClass().getSimpleName());
+            }
+        }
+
+        builder.endMap(mapKey, mapStart);
+    }
+
+    private void addVector(FlexBuffersBuilder builder, String vectorKey, List<Object> list) {
+        int vectorStart = builder.startVector();
+
+        for (Object item : list) {
+            if (item == null) {
+                builder.putNull();
+            } else if (item instanceof Map) {
+                //noinspection unchecked
+                addMap(builder, null, (Map<Object, Object>) item);
+            } else if (item instanceof List) {
+                //noinspection unchecked
+                addVector(builder, null, (List<Object>) item);
+            } else if (item instanceof String) {
+                builder.putString((String) item);
+            } else if (item instanceof Boolean) {
+                builder.putBoolean((Boolean) item);
+            } else if (item instanceof Byte) {
+                // Will always be restored as Integer.
+                builder.putInt(((Byte) item).intValue());
+            } else if (item instanceof Short) {
+                // Will always be restored as Integer.
+                builder.putInt(((Short) item).intValue());
+            } else if (item instanceof Integer) {
+                builder.putInt((Integer) item);
+            } else if (item instanceof Long) {
+                builder.putInt((Long) item);
+            } else if (item instanceof Float) {
+                builder.putFloat((Float) item);
+            } else if (item instanceof Double) {
+                builder.putFloat((Double) item);
+            } else if (item instanceof byte[]) {
+                builder.putBlob((byte[]) item);
+            } else {
+                throw new IllegalArgumentException(
+                        "List values of this type are not supported: " + item.getClass().getSimpleName());
+            }
+        }
+
+        builder.endVector(vectorKey, vectorStart, false, false);
+    }
+
+    @Override
+    public Object convertToEntityProperty(byte[] databaseValue) {
+        if (databaseValue == null) return null;
+
+        FlexBuffers.Reference value = FlexBuffers.getRoot(new ArrayReadWriteBuf(databaseValue, databaseValue.length));
+        if (value.isNull()) {
+            return null;
+        } else if (value.isMap()) {
+            return buildMap(value.asMap());
+        } else if (value.isVector()) {
+            return buildList(value.asVector());
+        } else if (value.isString()) {
+            return value.asString();
+        } else if (value.isBoolean()) {
+            return value.asBoolean();
+        } else if (value.isInt()) {
+            if (shouldRestoreAsLong(value)) {
+                return value.asLong();
+            } else {
+                return value.asInt();
+            }
+        } else if (value.isFloat()) {
+            // Always return as double; if original was float consumer can cast to obtain original value.
+            return value.asFloat();
+        } else if (value.isBlob()) {
+            return value.asBlob().getBytes();
+        } else {
+            throw new IllegalArgumentException("FlexBuffers type is not supported: " + value.getType());
+        }
+    }
+
+    /**
+     * Converts a FlexBuffers string map key to the Java map key (e.g. String to Integer).
+     * <p>
+     * This required conversion restricts all keys (root and embedded maps) to the same type.
+     */
+    Object convertToKey(String keyValue) {
+        return keyValue;
+    }
+
+    /**
+     * Returns true if the width in bytes stored in the private parentWidth field of FlexBuffers.Reference is 8.
+     * Note: FlexBuffers stores all items in a map/vector using the size of the widest item. However,
+     * an item's size is only as wide as needed, e.g. a 64-bit integer (Java Long, 8 bytes) will be
+     * reduced to 1 byte if it does not exceed its value range.
+     */
+    protected boolean shouldRestoreAsLong(FlexBuffers.Reference reference) {
+        try {
+            Field parentWidthF = reference.getClass().getDeclaredField("parentWidth");
+            parentWidthF.setAccessible(true);
+            return (int) parentWidthF.get(reference) == 8;
+        } catch (Exception e) {
+            // If thrown, it is likely the FlexBuffers API has changed and the above should be updated.
+            throw new RuntimeException("FlexMapConverter could not determine FlexBuffers integer bit width.", e);
+        }
+    }
+
+    private Map<Object, Object> buildMap(FlexBuffers.Map map) {
+        // As recommended by docs, iterate keys and values vectors in parallel to avoid binary search of key vector.
+        int entryCount = map.size();
+        FlexBuffers.KeyVector keys = map.keys();
+        FlexBuffers.Vector values = map.values();
+        // Note: avoid HashMap re-hashing by choosing large enough initial capacity.
+        // From docs: If the initial capacity is greater than the maximum number of entries divided by the load factor,
+        // no rehash operations will ever occur.
+        // So set initial capacity based on default load factor 0.75 accordingly.
+        Map<Object, Object> resultMap = new HashMap<>((int) (entryCount / 0.75 + 1));
+        for (int i = 0; i < entryCount; i++) {
+            String rawKey = keys.get(i).toString();
+            Object key = convertToKey(rawKey);
+            FlexBuffers.Reference value = values.get(i);
+            if (value.isNull()) {
+                resultMap.put(key, null);
+            } else if (value.isMap()) {
+                resultMap.put(key, buildMap(value.asMap()));
+            } else if (value.isVector()) {
+                resultMap.put(key, buildList(value.asVector()));
+            } else if (value.isString()) {
+                resultMap.put(key, value.asString());
+            } else if (value.isBoolean()) {
+                resultMap.put(key, value.asBoolean());
+            } else if (value.isInt()) {
+                if (shouldRestoreAsLong(value)) {
+                    resultMap.put(key, value.asLong());
+                } else {
+                    resultMap.put(key, value.asInt());
+                }
+            } else if (value.isFloat()) {
+                // Always return as double; if original was float consumer can cast to obtain original value.
+                resultMap.put(key, value.asFloat());
+            } else if (value.isBlob()) {
+                resultMap.put(key, value.asBlob().getBytes());
+            } else {
+                throw new IllegalArgumentException(
+                        "Map values of this type are not supported: " + value.getClass().getSimpleName());
+            }
+        }
+
+        return resultMap;
+    }
+
+    private List<Object> buildList(FlexBuffers.Vector vector) {
+        int itemCount = vector.size();
+        List<Object> list = new ArrayList<>(itemCount);
+
+        // FlexBuffers uses the byte width of the biggest item to size all items, so only need to check the first.
+        Boolean shouldRestoreAsLong = null;
+
+        for (int i = 0; i < itemCount; i++) {
+            FlexBuffers.Reference item = vector.get(i);
+            if (item.isNull()) {
+                list.add(null);
+            } else if (item.isMap()) {
+                list.add(buildMap(item.asMap()));
+            } else if (item.isVector()) {
+                list.add(buildList(item.asVector()));
+            } else if (item.isString()) {
+                list.add(item.asString());
+            } else if (item.isBoolean()) {
+                list.add(item.asBoolean());
+            } else if (item.isInt()) {
+                if (shouldRestoreAsLong == null) {
+                    shouldRestoreAsLong = shouldRestoreAsLong(item);
+                }
+                if (shouldRestoreAsLong) {
+                    list.add(item.asLong());
+                } else {
+                    list.add(item.asInt());
+                }
+            } else if (item.isFloat()) {
+                // Always return as double; if original was float consumer can cast to obtain original value.
+                list.add(item.asFloat());
+            } else if (item.isBlob()) {
+                list.add(item.asBlob().getBytes());
+            } else {
+                throw new IllegalArgumentException(
+                        "List values of this type are not supported: " + item.getClass().getSimpleName());
+            }
+        }
+
+        return list;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java
new file mode 100644
index 00000000..04707ffd
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/IntegerFlexMapConverter.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+/**
+ * A {@link FlexObjectConverter} that uses {@link Integer} as map keys.
+ * <p>
+ * Used by default to convert {@code Map<Integer, V>}.
+ */
+public class IntegerFlexMapConverter extends FlexObjectConverter {
+
+    @Override
+    protected void checkMapKeyType(Object rawKey) {
+        if (!(rawKey instanceof Integer)) {
+            throw new IllegalArgumentException("Map keys must be Integer");
+        }
+    }
+
+    @Override
+    Integer convertToKey(String keyValue) {
+        return Integer.valueOf(keyValue);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java
new file mode 100644
index 00000000..17b40518
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/IntegerLongMapConverter.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import io.objectbox.flatbuffers.FlexBuffers;
+
+/**
+ * Like {@link IntegerFlexMapConverter}, but always restores integer map values as {@link Long}.
+ * <p>
+ * Used by default to convert {@code Map<Integer, Long>}.
+ */
+public class IntegerLongMapConverter extends IntegerFlexMapConverter {
+    @Override
+    protected boolean shouldRestoreAsLong(FlexBuffers.Reference reference) {
+        return true; // Restore all integers as java.lang.Long.
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java
new file mode 100644
index 00000000..d897ecce
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/LongFlexMapConverter.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+/**
+ * A {@link FlexObjectConverter} that uses {@link Long} as map keys.
+ * <p>
+ * Used by default to convert {@code Map<Long, V>}.
+ */
+public class LongFlexMapConverter extends FlexObjectConverter {
+
+    @Override
+    protected void checkMapKeyType(Object rawKey) {
+        if (!(rawKey instanceof Long)) {
+            throw new IllegalArgumentException("Map keys must be Long");
+        }
+    }
+
+    @Override
+    Object convertToKey(String keyValue) {
+        return Long.valueOf(keyValue);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java
new file mode 100644
index 00000000..e11f8dba
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/LongLongMapConverter.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import io.objectbox.flatbuffers.FlexBuffers;
+
+/**
+ * Like {@link LongFlexMapConverter}, but always restores integer map values as {@link Long}.
+ * <p>
+ * Used by default to convert {@code Map<Long, Long>}.
+ */
+public class LongLongMapConverter extends LongFlexMapConverter {
+    @Override
+    protected boolean shouldRestoreAsLong(FlexBuffers.Reference reference) {
+        return true; // Restore all integers as java.lang.Long.
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java
index 1f8873fd..df0bcbff 100644
--- a/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java
+++ b/objectbox-java/src/main/java/io/objectbox/converter/NullToEmptyStringConverter.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package io.objectbox.converter;
 
 import javax.annotation.Nullable;
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java
new file mode 100644
index 00000000..01229760
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/StringFlexMapConverter.java
@@ -0,0 +1,25 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+/**
+ * A {@link FlexObjectConverter}.
+ * <p>
+ * Used by default to convert {@code Map<String, V>}.
+ */
+public class StringFlexMapConverter extends FlexObjectConverter {
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java
new file mode 100644
index 00000000..c1347071
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/StringLongMapConverter.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import io.objectbox.flatbuffers.FlexBuffers;
+
+/**
+ * Like {@link StringFlexMapConverter}, but always restores integer map values as {@link Long}.
+ * <p>
+ * Used by default to convert {@code Map<String, Long>}.
+ */
+public class StringLongMapConverter extends StringFlexMapConverter {
+    @Override
+    protected boolean shouldRestoreAsLong(FlexBuffers.Reference reference) {
+        return true; // Restore all integers as java.lang.Long.
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java b/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java
new file mode 100644
index 00000000..0fab3d26
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/converter/StringMapConverter.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2020-2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import io.objectbox.flatbuffers.ArrayReadWriteBuf;
+import io.objectbox.flatbuffers.FlexBuffers;
+import io.objectbox.flatbuffers.FlexBuffersBuilder;
+
+import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.concurrent.atomic.AtomicReference;
+
+/**
+ * Converts a String map entity property to a byte array database value using FlexBuffers.
+ */
+public class StringMapConverter implements PropertyConverter<Map<String, String>, byte[]> {
+
+    private static final AtomicReference<FlexBuffersBuilder> cachedBuilder = new AtomicReference<>();
+
+    @Override
+    public byte[] convertToDatabaseValue(Map<String, String> map) {
+        if (map == null) return null;
+
+        FlexBuffersBuilder builder = cachedBuilder.getAndSet(null);
+        if (builder == null) {
+            // Note: BUILDER_FLAG_SHARE_KEYS_AND_STRINGS is as fast as no flags for small maps/strings
+            // and faster for larger maps/strings. BUILDER_FLAG_SHARE_STRINGS is always slower.
+            builder = new FlexBuffersBuilder(
+                    new ArrayReadWriteBuf(512),
+                    FlexBuffersBuilder.BUILDER_FLAG_SHARE_KEYS_AND_STRINGS
+            );
+        }
+        int mapStart = builder.startMap();
+
+        for (Entry<String, String> entry : map.entrySet()) {
+            if (entry.getKey() == null || entry.getValue() == null) {
+                throw new IllegalArgumentException("Map keys or values must not be null");
+            }
+            builder.putString(entry.getKey(), entry.getValue());
+        }
+
+        builder.endMap(null, mapStart);
+        ByteBuffer buffer = builder.finish();
+
+        byte[] out = new byte[buffer.limit()];
+        buffer.get(out);
+
+        // Cache if builder does not consume too much memory
+        if (buffer.limit() <= 256 * 1024) {
+            builder.clear();
+            cachedBuilder.getAndSet(builder);
+        }
+
+        return out;
+    }
+
+    @Override
+    public Map<String, String> convertToEntityProperty(byte[] databaseValue) {
+        if (databaseValue == null) return null;
+
+        FlexBuffers.Map map = FlexBuffers.getRoot(new ArrayReadWriteBuf(databaseValue, databaseValue.length)).asMap();
+
+        // As recommended by docs, iterate keys and values vectors in parallel to avoid binary search of key vector.
+        int entryCount = map.size();
+        FlexBuffers.KeyVector keys = map.keys();
+        FlexBuffers.Vector values = map.values();
+        // Note: avoid HashMap re-hashing by choosing large enough initial capacity.
+        // From docs: If the initial capacity is greater than the maximum number of entries divided by the load factor,
+        // no rehash operations will ever occur.
+        // So set initial capacity based on default load factor 0.75 accordingly.
+        Map<String, String> resultMap = new HashMap<>((int) (entryCount / 0.75 + 1));
+        for (int i = 0; i < entryCount; i++) {
+            String key = keys.get(i).toString();
+            String value = values.get(i).asString();
+            resultMap.put(key, value);
+        }
+
+        return resultMap;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java b/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java
index 29088db7..3fe5b2c7 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/ConstraintViolationException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java
index 65b47dba..066ab5e7 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbDetachedException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,23 @@
 
 package io.objectbox.exception;
 
+/**
+ * This exception occurs while working with a {@link io.objectbox.relation.ToMany ToMany} or
+ * {@link io.objectbox.relation.ToOne ToOne} of an object and the object is not attached to a
+ * {@link io.objectbox.Box Box} (technically a {@link io.objectbox.BoxStore BoxStore}).
+ * <p>
+ * If your code uses <a href="https://docs.objectbox.io/advanced/object-ids#self-assigned-object-ids">manually assigned
+ * IDs</a> make sure it takes care of some things that ObjectBox would normally do by itself. This includes
+ * {@link io.objectbox.Box#attach(Object) attaching} the Box to an object before modifying a ToMany.
+ * <p>
+ * Also see the documentation about <a href="https://docs.objectbox.io/relations#updating-relations">Updating
+ * Relations</a> and <a href="https://docs.objectbox.io/advanced/object-ids#self-assigned-object-ids">manually assigned
+ * IDs</a> for details.
+ */
 public class DbDetachedException extends DbException {
 
     public DbDetachedException() {
-        this("Cannot perform this action on a detached entity. " +
-                "Ensure it was loaded by ObjectBox, or attach it manually.");
+        this("Entity must be attached to a Box.");
     }
 
     public DbDetachedException(String message) {
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbException.java
index f1cd7967..7ec46060 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java b/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java
index d346280f..0c72d6b1 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbExceptionListener.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018-2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,11 +16,30 @@
 
 package io.objectbox.exception;
 
+import io.objectbox.annotation.apihint.Experimental;
+
 /**
  * Listener for exceptions occurring during database operations.
  * Set via {@link io.objectbox.BoxStore#setDbExceptionListener(DbExceptionListener)}.
  */
 public interface DbExceptionListener {
+    /**
+     * WARNING/DISCLAIMER: Please avoid this method and handle exceptions "properly" instead.
+     * By using this method, you "hack" into the exception handling by preventing native core exceptions to be
+     * raised in Java. This typically results in methods returning zero or null regardless if this breaks any
+     * non-zero or non-null contract that would be in place otherwise. Additionally, "canceling" exceptions
+     * may lead to unforeseen follow-up errors that would never occur otherwise. In short, by using this method
+     * you are accepting undefined behavior.
+     * <p>
+     * Also note that it is likely that this method will never graduate from @{@link Experimental} until it is removed.
+     * <p>
+     * This method may be only called from {@link #onDbException(Exception)}.
+     */
+    @Experimental
+    static void cancelCurrentException() {
+        DbExceptionListenerJni.nativeCancelCurrentException();
+    }
+
     /**
      * Called when an exception is thrown during a database operation.
      * Do NOT throw exceptions in this method: throw exceptions are ignored (but logged to stderr).
@@ -29,3 +48,12 @@ public interface DbExceptionListener {
      */
     void onDbException(Exception e);
 }
+
+/**
+ * Interface cannot have native methods.
+ */
+class DbExceptionListenerJni {
+    native static void nativeCancelCurrentException();
+
+    native static void nativeThrowException(long nativeStore, int exNo);
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java
index 5b0da063..8aa7c2c3 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbFullException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,13 @@
 
 package io.objectbox.exception;
 
+/**
+ * Thrown when applying a database operation would exceed the (default)
+ * {@link io.objectbox.BoxStoreBuilder#maxSizeInKByte(long) maxSizeInKByte} configured for the Store.
+ * <p>
+ * This can occur for operations like when an Object is {@link io.objectbox.Box#put(Object) put}, at the point when the
+ * (internal) transaction is committed. Or when the Store is opened with a max size too small for the existing database.
+ */
 public class DbFullException extends DbException {
     public DbFullException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java
new file mode 100644
index 00000000..a0f5ac16
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxDataSizeExceededException.java
@@ -0,0 +1,27 @@
+/*
+ * Copyright 2022 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.exception;
+
+/**
+ * Thrown when applying a transaction would exceed the {@link io.objectbox.BoxStoreBuilder#maxDataSizeInKByte(long) maxDataSizeInKByte}
+ * configured for the store.
+ */
+public class DbMaxDataSizeExceededException extends DbException {
+    public DbMaxDataSizeExceededException(String message) {
+        super(message);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java
index d3587778..98bcc062 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbMaxReadersExceededException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,9 +21,9 @@
 
 /**
  * Thrown when the maximum of readers (read transactions) was exceeded.
- * Verify that you run a reasonable amount of threads only.
+ * Verify that your code only uses a reasonable amount of threads.
  * <p>
- * If you intend to work with a very high number of threads (&gt;100), consider increasing the number of maximum readers
+ * If a very high number of threads (&gt;100) needs to be used, consider increasing the number of maximum readers
  * using {@link BoxStoreBuilder#maxReaders(int)} and enabling query retries using
  * {@link BoxStoreBuilder#queryAttempts(int)}.
  * <p>
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java
index a337915e..0b8778c0 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbSchemaException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,15 @@
 
 package io.objectbox.exception;
 
+/**
+ * Thrown when there is an error with the data schema (data model).
+ * <p>
+ * Typically, there is a conflict between the data model defined in your code (using {@link io.objectbox.annotation.Entity @Entity}
+ * classes) and the data model of the existing database file.
+ * <p>
+ * Read the <a href="https://docs.objectbox.io/advanced/meta-model-ids-and-uids#resolving-meta-model-conflicts">meta model docs</a>
+ * on why this can happen and how to resolve such conflicts.
+ */
 public class DbSchemaException extends DbException {
     public DbSchemaException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java b/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java
index 3cf4b69e..6b06895c 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/DbShutdownException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,10 +17,10 @@
 package io.objectbox.exception;
 
 /**
- * Thrown when an error occurred that requires the DB to shutdown.
- * This may be an I/O error for example.
- * Regular operations won't be possible anymore.
- * To handle that situation you could exit the app or try to reopen the store.
+ * Thrown when an error occurred that requires the store to be closed.
+ * <p>
+ * This may be an I/O error. Regular operations won't be possible.
+ * To handle this exit the app or try to reopen the store.
  */
 public class DbShutdownException extends DbException {
     public DbShutdownException(String message) {
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/FeatureNotAvailableException.java b/objectbox-java/src/main/java/io/objectbox/exception/FeatureNotAvailableException.java
new file mode 100644
index 00000000..cb87a23a
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/exception/FeatureNotAvailableException.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.exception;
+
+/**
+ * Thrown when a special feature was used, which is not part of the native library.
+ * <p>
+ * This typically indicates a developer error. Check that the correct dependencies for the native ObjectBox library are
+ * included.
+ */
+public class FeatureNotAvailableException extends DbException {
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public FeatureNotAvailableException(String message) {
+        super(message);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java b/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java
new file mode 100644
index 00000000..076e1117
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/exception/FileCorruptException.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.objectbox.exception;
+
+import io.objectbox.BoxStoreBuilder;
+
+/**
+ * Errors were detected in a database file, e.g. illegal values or structural inconsistencies.
+ * <p>
+ * It may be possible to re-open the store with {@link BoxStoreBuilder#usePreviousCommit()} to restore
+ * to a working state.
+ */
+public class FileCorruptException extends DbException {
+    public FileCorruptException(String message) {
+        super(message);
+    }
+
+    public FileCorruptException(String message, int errorCode) {
+        super(message, errorCode);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java b/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java
index 4eb4dbdf..c2f4f49c 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/NonUniqueResultException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,11 @@
 
 package io.objectbox.exception;
 
-/** Throw if {@link io.objectbox.query.Query#findUnique()} returns more than one result. */
+/**
+ * Thrown if {@link io.objectbox.query.Query#findUnique() Query.findUnique()} or
+ * {@link io.objectbox.query.Query#findUniqueId() Query.findUniqueId()} is called,
+ * but the query matches more than one object.
+ */
 public class NonUniqueResultException extends DbException {
     public NonUniqueResultException(String message) {
         super(message);
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java b/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java
index 8ab0c395..7a283dcc 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/NumericOverflowException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java b/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java
new file mode 100644
index 00000000..bcc2474f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/exception/PagesCorruptException.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.objectbox.exception;
+
+/**
+ * Errors related to pages were detected in a database file, e.g. bad page refs outside of the file.
+ */
+public class PagesCorruptException extends FileCorruptException {
+    public PagesCorruptException(String message) {
+        super(message);
+    }
+
+    public PagesCorruptException(String message, int errorCode) {
+        super(message, errorCode);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java b/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java
index 023bbbac..ec0f2b37 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/UniqueViolationException.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2018 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/exception/package-info.java b/objectbox-java/src/main/java/io/objectbox/exception/package-info.java
index c389e4c5..ed0d08d0 100644
--- a/objectbox-java/src/main/java/io/objectbox/exception/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/exception/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2019 ObjectBox Ltd. All rights reserved.
+ * Copyright 2019 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ArrayReadWriteBuf.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ArrayReadWriteBuf.java
new file mode 100644
index 00000000..a952afba
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ArrayReadWriteBuf.java
@@ -0,0 +1,252 @@
+package io.objectbox.flatbuffers;
+
+import java.util.Arrays;
+
+/**
+ * Implements {@code ReadBuf} using an array of bytes
+ * as a backing storage. Using array of bytes are
+ * usually faster than {@code ByteBuffer}.
+ *
+ * This class is not thread-safe, meaning that
+ * it must operate on a single thread. Operating from
+ * multiple thread leads into a undefined behavior
+ */
+public class ArrayReadWriteBuf implements ReadWriteBuf {
+
+  private byte[] buffer;
+  private int writePos;
+
+  public ArrayReadWriteBuf() {
+    this(10);
+  }
+
+  public ArrayReadWriteBuf(int initialCapacity) {
+    this(new byte[initialCapacity]);
+  }
+
+  public ArrayReadWriteBuf(byte[] buffer) {
+    this.buffer = buffer;
+    this.writePos = 0;
+  }
+
+  public ArrayReadWriteBuf(byte[] buffer, int startPos) {
+    this.buffer = buffer;
+    this.writePos = startPos;
+  }
+
+  @Override
+  public void clear() {
+    this.writePos = 0;
+  }
+
+  @Override
+  public boolean getBoolean(int index) {
+    return buffer[index] != 0;
+  }
+
+  @Override
+  public byte get(int index) {
+    return buffer[index];
+  }
+
+  @Override
+  public short getShort(int index) {
+    return (short) ((buffer[index+ 1] << 8) | (buffer[index] & 0xff));
+  }
+
+  @Override
+  public int getInt(int index) {
+    return (((buffer[index + 3]) << 24) |
+      ((buffer[index + 2] & 0xff) << 16) |
+      ((buffer[index + 1] & 0xff) << 8) |
+      ((buffer[index] & 0xff)));
+  }
+
+  @Override
+  public long getLong(int index) {
+    return ((((long) buffer[index++] & 0xff)) |
+      (((long) buffer[index++] & 0xff) << 8) |
+      (((long) buffer[index++] & 0xff) << 16) |
+      (((long) buffer[index++] & 0xff) << 24) |
+      (((long) buffer[index++] & 0xff) << 32) |
+      (((long) buffer[index++] & 0xff) << 40) |
+      (((long) buffer[index++] & 0xff) << 48) |
+      (((long) buffer[index]) << 56));
+  }
+
+  @Override
+  public float getFloat(int index) {
+    return Float.intBitsToFloat(getInt(index));
+  }
+
+  @Override
+  public double getDouble(int index) {
+    return Double.longBitsToDouble(getLong(index));
+  }
+
+  @Override
+  public String getString(int start, int size) {
+    return Utf8Safe.decodeUtf8Array(buffer, start, size);
+  }
+
+  @Override
+  public byte[] data() {
+    return buffer;
+  }
+
+
+  @Override
+  public void putBoolean(boolean value) {
+      setBoolean(writePos, value);
+      writePos++;
+  }
+
+  @Override
+  public void put(byte[] value, int start, int length) {
+    set(writePos, value, start, length);
+    writePos+=length;
+  }
+
+  @Override
+  public void put(byte value) {
+    set(writePos, value);
+    writePos++;
+  }
+
+  @Override
+  public void putShort(short value) {
+    setShort(writePos, value);
+    writePos +=2;
+  }
+
+  @Override
+  public void putInt(int value) {
+    setInt(writePos, value);
+    writePos +=4;
+  }
+
+  @Override
+  public void putLong(long value) {
+    setLong(writePos, value);
+    writePos +=8;
+  }
+
+  @Override
+  public void putFloat(float value) {
+    setFloat(writePos, value);
+    writePos +=4;
+  }
+
+  @Override
+  public void putDouble(double value) {
+    setDouble(writePos, value);
+    writePos +=8;
+  }
+
+  @Override
+  public void setBoolean(int index, boolean value) {
+    set(index, value ? (byte)1 : (byte)0);
+  }
+
+  @Override
+  public void set(int index, byte value) {
+    requestCapacity(index + 1);
+    buffer[index] = value;
+  }
+
+  @Override
+  public void set(int index, byte[] toCopy, int start, int length) {
+    requestCapacity(index + (length - start));
+    System.arraycopy(toCopy, start, buffer, index, length);
+  }
+
+  @Override
+  public void setShort(int index, short value) {
+    requestCapacity(index + 2);
+
+    buffer[index++] = (byte) ((value) & 0xff);
+    buffer[index  ] = (byte) ((value >> 8) & 0xff);
+  }
+
+  @Override
+  public void setInt(int index, int value) {
+    requestCapacity(index + 4);
+
+    buffer[index++] = (byte) ((value) & 0xff);
+    buffer[index++] = (byte) ((value >>  8) & 0xff);
+    buffer[index++] = (byte) ((value >> 16) & 0xff);
+    buffer[index  ] = (byte) ((value >> 24) & 0xff);
+  }
+
+  @Override
+  public void setLong(int index, long value) {
+    requestCapacity(index + 8);
+
+    int i = (int) value;
+    buffer[index++] = (byte) ((i) & 0xff);
+    buffer[index++] = (byte) ((i >>  8) & 0xff);
+    buffer[index++] = (byte) ((i >> 16) & 0xff);
+    buffer[index++] = (byte) ((i >> 24) & 0xff);
+    i = (int) (value >> 32);
+    buffer[index++] = (byte) ((i) & 0xff);
+    buffer[index++] = (byte) ((i >>  8) & 0xff);
+    buffer[index++] = (byte) ((i >> 16) & 0xff);
+    buffer[index  ] = (byte) ((i >> 24) & 0xff);
+  }
+
+  @Override
+  public void setFloat(int index, float value) {
+    requestCapacity(index + 4);
+
+    int iValue = Float.floatToRawIntBits(value);
+    buffer[index++] = (byte) ((iValue) & 0xff);
+    buffer[index++] = (byte) ((iValue >>  8) & 0xff);
+    buffer[index++] = (byte) ((iValue >> 16) & 0xff);
+    buffer[index  ] = (byte) ((iValue >> 24) & 0xff);
+  }
+
+  @Override
+  public void setDouble(int index, double value) {
+    requestCapacity(index + 8);
+
+    long lValue = Double.doubleToRawLongBits(value);
+    int i = (int) lValue;
+    buffer[index++] = (byte) ((i) & 0xff);
+    buffer[index++] = (byte) ((i >>  8) & 0xff);
+    buffer[index++] = (byte) ((i >> 16) & 0xff);
+    buffer[index++] = (byte) ((i >> 24) & 0xff);
+    i = (int) (lValue >> 32);
+    buffer[index++] = (byte) ((i) & 0xff);
+    buffer[index++] = (byte) ((i >>  8) & 0xff);
+    buffer[index++] = (byte) ((i >> 16) & 0xff);
+    buffer[index  ] = (byte) ((i >> 24) & 0xff);
+  }
+
+  @Override
+  public int limit() {
+    return writePos;
+  }
+
+  @Override
+  public int writePosition() {
+    return writePos;
+  }
+
+  @Override
+  public boolean requestCapacity(int capacity) {
+    if (capacity < 0) {
+      throw new IllegalArgumentException("Capacity may not be negative (likely a previous int overflow)");
+    }
+    if (buffer.length >= capacity) {
+      return true;
+    }
+    // implemented in the same growing fashion as ArrayList
+    int oldCapacity = buffer.length;
+    int newCapacity = oldCapacity + (oldCapacity >> 1);
+    if (newCapacity < capacity) {  // Note: this also catches newCapacity int overflow
+      newCapacity = capacity;
+    }
+    buffer = Arrays.copyOf(buffer, newCapacity);
+    return true;
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/BaseVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/BaseVector.java
new file mode 100644
index 00000000..8b0c1fdc
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/BaseVector.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import java.nio.ByteBuffer;
+
+/// @cond FLATBUFFERS_INTERNAL
+
+/**
+ * All vector access objects derive from this class, and add their own accessors.
+ */
+public class BaseVector {
+  /** Used to hold the vector data position. */
+  private int vector;
+  /** Used to hold the vector size. */
+  private int length;
+  /** Used to hold the vector element size in table. */
+  private int element_size;
+  /** The underlying ByteBuffer to hold the data of the vector. */
+  protected ByteBuffer bb;
+
+  /**
+   * Get the start data of a vector.
+   *
+   * @return Returns the start of the vector data.
+   */
+  protected int __vector() {
+    return vector;
+  }
+
+  /**
+   * Gets the element position in vector's ByteBuffer.
+   *
+   * @param j An `int` index of element into a vector.
+   * @return Returns the position of the vector element in a ByteBuffer.
+   */
+  protected int __element(int j) {
+    return vector + j * element_size;
+  }
+
+  /**
+   * Re-init the internal state with an external buffer {@code ByteBuffer}, an offset within and
+   * element size.
+   *
+   * This method exists primarily to allow recycling vector instances without risking memory leaks
+   * due to {@code ByteBuffer} references.
+   */
+  protected void __reset(int _vector, int _element_size, ByteBuffer _bb) { 
+    bb = _bb;
+    if (bb != null) {
+      vector = _vector;
+      length = bb.getInt(_vector - Constants.SIZEOF_INT);
+      element_size = _element_size;
+    } else {
+      vector = 0;
+      length = 0;
+      element_size = 0;
+    }
+  }
+
+  /**
+   * Resets the internal state with a null {@code ByteBuffer} and a zero position.
+   *
+   * This method exists primarily to allow recycling vector instances without risking memory leaks
+   * due to {@code ByteBuffer} references. The instance will be unusable until it is assigned
+   * again to a {@code ByteBuffer}.
+   */
+  public void reset() {
+    __reset(0, 0, null);
+  }
+
+  /**
+   * Get the length of a vector.
+   *
+   * @return Returns the length of the vector.
+   */
+  public int length() {
+    return length;
+  }
+}
+
+/// @endcond
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/BooleanVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/BooleanVector.java
new file mode 100644
index 00000000..718451ee
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/BooleanVector.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of booleans.
+ */
+public final class BooleanVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public BooleanVector __assign(int _vector, ByteBuffer _bb) {
+    __reset(_vector, Constants.SIZEOF_BYTE, _bb); return this;
+  }
+
+  /**
+   * Reads the boolean at the given index.
+   *
+   * @param j The index from which the boolean will be read.
+   * @return the boolean value at the given index.
+   */
+  public boolean get(int j) { 
+    return 0 != bb.get(__element(j));
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteBufferReadWriteBuf.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteBufferReadWriteBuf.java
new file mode 100644
index 00000000..1bc3d919
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteBufferReadWriteBuf.java
@@ -0,0 +1,170 @@
+package io.objectbox.flatbuffers;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+public class ByteBufferReadWriteBuf implements ReadWriteBuf {
+
+  private final ByteBuffer buffer;
+
+  public ByteBufferReadWriteBuf(ByteBuffer bb) {
+    this.buffer = bb;
+    this.buffer.order(ByteOrder.LITTLE_ENDIAN);
+  }
+
+  @Override
+  public void clear() {
+    buffer.clear();
+  }
+
+  @Override
+  public boolean getBoolean(int index) {
+    return get(index) != 0;
+  }
+
+  @Override
+  public byte get(int index) {
+    return buffer.get(index);
+  }
+
+  @Override
+  public short getShort(int index) {
+    return buffer.getShort(index);
+  }
+
+  @Override
+  public int getInt(int index) {
+    return buffer.getInt(index);
+  }
+
+  @Override
+  public long getLong(int index) {
+    return buffer.getLong(index);
+  }
+
+  @Override
+  public float getFloat(int index) {
+    return buffer.getFloat(index);
+  }
+
+  @Override
+  public double getDouble(int index) {
+    return buffer.getDouble(index);
+  }
+
+  @Override
+  public String getString(int start, int size) {
+    return Utf8Safe.decodeUtf8Buffer(buffer, start, size);
+  }
+
+  @Override
+  public byte[] data() {
+    return buffer.array();
+  }
+
+  @Override
+  public void putBoolean(boolean value) {
+    buffer.put(value ? (byte)1 : (byte)0);
+  }
+
+  @Override
+  public void put(byte[] value, int start, int length) {
+    buffer.put(value, start, length);
+  }
+
+  @Override
+  public void put(byte value) {
+    buffer.put(value);
+  }
+
+  @Override
+  public void putShort(short value) {
+    buffer.putShort(value);
+  }
+
+  @Override
+  public void putInt(int value) {
+    buffer.putInt(value);
+  }
+
+  @Override
+  public void putLong(long value) {
+    buffer.putLong(value);
+  }
+
+  @Override
+  public void putFloat(float value) {
+    buffer.putFloat(value);
+  }
+
+  @Override
+  public void putDouble(double value) {
+    buffer.putDouble(value);
+  }
+
+  @Override
+  public void setBoolean(int index, boolean value) {
+    set(index, value ? (byte)1 : (byte)0);
+  }
+
+  @Override
+  public void set(int index, byte value) {
+    requestCapacity(index + 1);
+    buffer.put(index, value);
+  }
+
+  @Override
+  public void set(int index, byte[] value, int start, int length) {
+    requestCapacity(index + (length - start));
+    int curPos = buffer.position();
+    buffer.position(index);
+    buffer.put(value, start, length);
+    buffer.position(curPos);
+  }
+
+  @Override
+  public void setShort(int index, short value) {
+    requestCapacity(index + 2);
+    buffer.putShort(index, value);
+  }
+
+  @Override
+  public void setInt(int index, int value) {
+    requestCapacity(index + 4);
+    buffer.putInt(index, value);
+  }
+
+  @Override
+  public void setLong(int index, long value) {
+    requestCapacity(index + 8);
+    buffer.putLong(index, value);
+  }
+
+  @Override
+  public void setFloat(int index, float value) {
+    requestCapacity(index + 4);
+    buffer.putFloat(index, value);
+  }
+
+  @Override
+  public void setDouble(int index, double value) {
+    requestCapacity(index + 8);
+    buffer.putDouble(index, value);
+  }
+
+  @Override
+  public int writePosition() {
+    return buffer.position();
+  }
+
+  @Override
+  public int limit() {
+    return buffer.limit();
+  }
+
+  @Override
+  public boolean requestCapacity(int capacity) {
+    return capacity <= buffer.limit();
+  }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteBufferUtil.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteBufferUtil.java
new file mode 100644
index 00000000..e4fde274
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteBufferUtil.java
@@ -0,0 +1,58 @@
+/*
+ * Copyright 2017 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+
+import java.nio.ByteBuffer;
+
+/// @file
+/// @addtogroup flatbuffers_java_api
+/// @{
+
+/**
+ * Class that collects utility functions around `ByteBuffer`.
+ */
+public class ByteBufferUtil {
+
+	/**
+     * Extract the size prefix from a `ByteBuffer`.
+     * 
+     * @param bb a size-prefixed buffer
+     * @return the size prefix
+     */
+    public static int getSizePrefix(ByteBuffer bb) {
+        return bb.getInt(bb.position());
+    }
+
+	/**
+     * Create a duplicate of a size-prefixed `ByteBuffer` that has its position
+     * advanced just past the size prefix.
+     * 
+     * @param bb a size-prefixed buffer
+     * @return a new buffer on the same underlying data that has skipped the
+     *         size prefix
+     */
+    public static ByteBuffer removeSizePrefix(ByteBuffer bb) {
+        ByteBuffer s = bb.duplicate();
+        s.position(s.position() + SIZE_PREFIX_LENGTH);
+        return s;
+    }
+
+}
+
+/// @}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteVector.java
new file mode 100644
index 00000000..f8d1c9f9
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ByteVector.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of signed or unsigned 8-bit values.
+ */
+public final class ByteVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param vector Start data of a vector.
+   * @param bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public ByteVector __assign(int vector, ByteBuffer bb) { 
+    __reset(vector, Constants.SIZEOF_BYTE, bb); return this;
+  }
+
+  /**
+   * Reads the byte at the given index.
+   *
+   * @param j The index from which the byte will be read.
+   * @return the 8-bit value at the given index.
+   */
+  public byte get(int j) {
+     return bb.get(__element(j));
+  }
+
+  /**
+   * Reads the byte at the given index, zero-extends it to type int, and returns the result,
+   * which is therefore in the range 0 through 255.
+   *
+   * @param j The index from which the byte will be read.
+   * @return the unsigned 8-bit at the given index.
+   */
+  public int getAsUnsigned(int j) {
+    return (int) get(j) & 0xFF;
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java
new file mode 100644
index 00000000..dc2949a5
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Constants.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+/// @cond FLATBUFFERS_INTERNAL
+
+/**
+ * Class that holds shared constants
+ */
+public class Constants {
+    // Java doesn't seem to have these.
+    /** The number of bytes in an `byte`. */
+    static final int SIZEOF_BYTE = 1;
+    /** The number of bytes in a `short`. */
+    static final int SIZEOF_SHORT = 2;
+    /** The number of bytes in an `int`. */
+    static final int SIZEOF_INT = 4;
+    /** The number of bytes in an `float`. */
+    static final int SIZEOF_FLOAT = 4;
+    /** The number of bytes in an `long`. */
+    static final int SIZEOF_LONG = 8;
+    /** The number of bytes in an `double`. */
+    static final int SIZEOF_DOUBLE = 8;
+    /** The number of bytes in a file identifier. */
+    static final int FILE_IDENTIFIER_LENGTH = 4;
+    /** The number of bytes in a size prefix. */
+    public static final int SIZE_PREFIX_LENGTH = 4;
+    /** A version identifier to force a compile error if someone
+    accidentally tries to build generated code with a runtime of
+    two mismatched version. Versions need to always match, as
+    the runtime and generated code are modified in sync.
+    Changes to the Java implementation need to be sure to change
+    the version here and in the code generator on every possible
+    incompatible change */
+    public static void FLATBUFFERS_23_5_26() {}
+}
+
+/// @endcond
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/DoubleVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/DoubleVector.java
new file mode 100644
index 00000000..31c9b9a0
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/DoubleVector.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of double values.
+ */
+public final class DoubleVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public DoubleVector __assign(int _vector, ByteBuffer _bb) {
+     __reset(_vector, Constants.SIZEOF_DOUBLE, _bb); return this;
+  }
+
+  /**
+   * Reads the double value at the given index.
+   *
+   * @param j The index from which the double value will be read.
+   * @return the double value at the given index.
+   */
+  public double get(int j) {
+    return bb.getDouble(__element(j));
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlatBufferBuilder.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlatBufferBuilder.java
new file mode 100644
index 00000000..9d1e39e0
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlatBufferBuilder.java
@@ -0,0 +1,1120 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.*;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.lang.Integer;
+
+/// @file
+/// @addtogroup flatbuffers_java_api
+/// @{
+
+/**
+ * Class that helps you build a FlatBuffer.  See the section
+ * "Use in Java/C#" in the main FlatBuffers documentation.
+ */
+public class FlatBufferBuilder {
+    /// @cond FLATBUFFERS_INTERNAL
+    ByteBuffer bb;                    // Where we construct the FlatBuffer.
+    int space;                        // Remaining space in the ByteBuffer.
+    int minalign = 1;                 // Minimum alignment encountered so far.
+    int[] vtable = null;              // The vtable for the current table.
+    int vtable_in_use = 0;            // The amount of fields we're actually using.
+    boolean nested = false;           // Whether we are currently serializing a table.
+    boolean finished = false;         // Whether the buffer is finished.
+    int object_start;                 // Starting offset of the current struct/table.
+    int[] vtables = new int[16];      // List of offsets of all vtables.
+    int num_vtables = 0;              // Number of entries in `vtables` in use.
+    int vector_num_elems = 0;         // For the current vector being built.
+    boolean force_defaults = false;   // False omits default values from the serialized data.
+    ByteBufferFactory bb_factory;     // Factory for allocating the internal buffer
+    final Utf8 utf8;                  // UTF-8 encoder to use
+    Map<String, Integer> string_pool; // map used to cache shared strings.
+    /// @endcond
+
+
+    /**
+     * Maximum size of buffer to allocate. If we're allocating arrays on the heap,
+     * the header size of the array counts towards its maximum size.
+     */
+    private static final int MAX_BUFFER_SIZE = Integer.MAX_VALUE - 8;
+
+    /**
+     * Default buffer size that is allocated if an initial size is not given, or is
+     * non positive.
+     */
+    private static final int DEFAULT_BUFFER_SIZE = 1024;
+
+    /**
+     * Start with a buffer of size `initial_size`, then grow as required.
+     *
+     * @param initial_size The initial size of the internal buffer to use.
+     * @param bb_factory The factory to be used for allocating the internal buffer
+     */
+    public FlatBufferBuilder(int initial_size, ByteBufferFactory bb_factory) {
+        this(initial_size, bb_factory, null, Utf8.getDefault());
+    }
+
+    /**
+     * Start with a buffer of size `initial_size`, then grow as required.
+     *
+     * @param initial_size The initial size of the internal buffer to use.
+     * @param bb_factory The factory to be used for allocating the internal buffer
+     * @param existing_bb The byte buffer to reuse.
+     * @param utf8 The Utf8 codec
+     */
+    public FlatBufferBuilder(int initial_size, ByteBufferFactory bb_factory,
+                             ByteBuffer existing_bb, Utf8 utf8) {
+        if (initial_size <= 0) {
+          initial_size = DEFAULT_BUFFER_SIZE;
+        }
+        this.bb_factory = bb_factory;
+        if (existing_bb != null) {
+          bb = existing_bb;
+          bb.clear();
+          bb.order(ByteOrder.LITTLE_ENDIAN);
+        } else {
+          bb = bb_factory.newByteBuffer(initial_size);
+        }
+        this.utf8 = utf8;
+        space = bb.capacity();
+    }
+
+   /**
+    * Start with a buffer of size `initial_size`, then grow as required.
+    *
+    * @param initial_size The initial size of the internal buffer to use.
+    */
+    public FlatBufferBuilder(int initial_size) {
+        this(initial_size, HeapByteBufferFactory.INSTANCE, null, Utf8.getDefault());
+    }
+
+    /**
+     * Start with a buffer of 1KiB, then grow as required.
+     */
+    public FlatBufferBuilder() {
+        this(DEFAULT_BUFFER_SIZE);
+    }
+
+    /**
+     * Alternative constructor allowing reuse of {@link ByteBuffer}s.  The builder
+     * can still grow the buffer as necessary.  User classes should make sure
+     * to call {@link #dataBuffer()} to obtain the resulting encoded message.
+     *
+     * @param existing_bb The byte buffer to reuse.
+     * @param bb_factory The factory to be used for allocating a new internal buffer if
+     *                   the existing buffer needs to grow
+     */
+    public FlatBufferBuilder(ByteBuffer existing_bb, ByteBufferFactory bb_factory) {
+        this(existing_bb.capacity(), bb_factory, existing_bb, Utf8.getDefault());
+    }
+
+    /**
+     * Alternative constructor allowing reuse of {@link ByteBuffer}s.  The builder
+     * can still grow the buffer as necessary.  User classes should make sure
+     * to call {@link #dataBuffer()} to obtain the resulting encoded message.
+     *
+     * @param existing_bb The byte buffer to reuse.
+     */
+    public FlatBufferBuilder(ByteBuffer existing_bb) {
+        this(existing_bb, new HeapByteBufferFactory());
+    }
+
+    /**
+     * Alternative initializer that allows reusing this object on an existing
+     * `ByteBuffer`. This method resets the builder's internal state, but keeps
+     * objects that have been allocated for temporary storage.
+     *
+     * @param existing_bb The byte buffer to reuse.
+     * @param bb_factory The factory to be used for allocating a new internal buffer if
+     *                   the existing buffer needs to grow
+     * @return Returns `this`.
+     */
+    public FlatBufferBuilder init(ByteBuffer existing_bb, ByteBufferFactory bb_factory){
+        this.bb_factory = bb_factory;
+        bb = existing_bb;
+        bb.clear();
+        bb.order(ByteOrder.LITTLE_ENDIAN);
+        minalign = 1;
+        space = bb.capacity();
+        vtable_in_use = 0;
+        nested = false;
+        finished = false;
+        object_start = 0;
+        num_vtables = 0;
+        vector_num_elems = 0;
+        if (string_pool != null) {
+            string_pool.clear();
+        }
+        return this;
+    }
+
+    /**
+     * An interface that provides a user of the FlatBufferBuilder class the ability to specify
+     * the method in which the internal buffer gets allocated. This allows for alternatives
+     * to the default behavior, which is to allocate memory for a new byte-array
+     * backed `ByteBuffer` array inside the JVM.
+     *
+     * The FlatBufferBuilder class contains the HeapByteBufferFactory class to
+     * preserve the default behavior in the event that the user does not provide
+     * their own implementation of this interface.
+     */
+    public static abstract class ByteBufferFactory {
+        /**
+         * Create a `ByteBuffer` with a given capacity.
+         * The returned ByteBuf must have a ByteOrder.LITTLE_ENDIAN ByteOrder.
+         *
+         * @param capacity The size of the `ByteBuffer` to allocate.
+         * @return Returns the new `ByteBuffer` that was allocated.
+         */
+        public abstract ByteBuffer newByteBuffer(int capacity);
+
+        /**
+         * Release a ByteBuffer. Current {@link FlatBufferBuilder}
+         * released any reference to it, so it is safe to dispose the buffer
+         * or return it to a pool.
+         * It is not guaranteed that the buffer has been created
+         * with {@link #newByteBuffer(int) }.
+         *
+         * @param bb the buffer to release
+         */
+        public void releaseByteBuffer(ByteBuffer bb) {
+        }
+    }
+
+    /**
+     * An implementation of the ByteBufferFactory interface that is used when
+     * one is not provided by the user.
+     *
+     * Allocate memory for a new byte-array backed `ByteBuffer` array inside the JVM.
+     */
+    public static final class HeapByteBufferFactory extends ByteBufferFactory {
+
+        public static final HeapByteBufferFactory INSTANCE = new HeapByteBufferFactory();
+
+        @Override
+        public ByteBuffer newByteBuffer(int capacity) {
+            return ByteBuffer.allocate(capacity).order(ByteOrder.LITTLE_ENDIAN);
+        }
+    }
+
+   /**
+   * Helper function to test if a field is present in the table
+   *
+   * @param table Flatbuffer table
+   * @param offset virtual table offset
+   * @return true if the filed is present
+   */
+   public static boolean isFieldPresent(Table table, int offset) {
+     return table.__offset(offset) != 0;
+   }
+
+    /**
+     * Reset the FlatBufferBuilder by purging all data that it holds.
+     */
+    public void clear(){
+        space = bb.capacity();
+        bb.clear();
+        minalign = 1;
+        while(vtable_in_use > 0) vtable[--vtable_in_use] = 0;
+        vtable_in_use = 0;
+        nested = false;
+        finished = false;
+        object_start = 0;
+        num_vtables = 0;
+        vector_num_elems = 0;
+        if (string_pool != null) {
+            string_pool.clear();
+        }
+    }
+
+    /**
+     * Doubles the size of the backing {@link ByteBuffer} and copies the old data towards the
+     * end of the new buffer (since we build the buffer backwards).
+     *
+     * @param bb The current buffer with the existing data.
+     * @param bb_factory The factory to be used for allocating the new internal buffer
+     * @return A new byte buffer with the old data copied copied to it.  The data is
+     * located at the end of the buffer.
+     */
+    static ByteBuffer growByteBuffer(ByteBuffer bb, ByteBufferFactory bb_factory) {
+        int old_buf_size = bb.capacity();
+
+        int new_buf_size;
+
+        if (old_buf_size == 0) {
+            new_buf_size = DEFAULT_BUFFER_SIZE;
+        }
+        else {
+            if (old_buf_size == MAX_BUFFER_SIZE) { // Ensure we don't grow beyond what fits in an int.
+                throw new AssertionError("FlatBuffers: cannot grow buffer beyond 2 gigabytes.");
+            }
+            new_buf_size = (old_buf_size & 0xC0000000) != 0 ? MAX_BUFFER_SIZE : old_buf_size << 1;
+        }
+
+        bb.position(0);
+        ByteBuffer nbb = bb_factory.newByteBuffer(new_buf_size);
+        new_buf_size = nbb.clear().capacity(); // Ensure the returned buffer is treated as empty
+        nbb.position(new_buf_size - old_buf_size);
+        nbb.put(bb);
+        return nbb;
+    }
+
+   /**
+    * Offset relative to the end of the buffer.
+    *
+    * @return Offset relative to the end of the buffer.
+    */
+    public int offset() {
+        return bb.capacity() - space;
+    }
+
+   /**
+    * Add zero valued bytes to prepare a new entry to be added.
+    *
+    * @param byte_size Number of bytes to add.
+    */
+    public void pad(int byte_size) {
+        for (int i = 0; i < byte_size; i++) bb.put(--space, (byte)0);
+    }
+
+   /**
+    * Prepare to write an element of `size` after `additional_bytes`
+    * have been written, e.g. if you write a string, you need to align such
+    * the int length field is aligned to {@link io.objectbox.flatbuffers.Constants#SIZEOF_INT}, and
+    * the string data follows it directly.  If all you need to do is alignment, `additional_bytes`
+    * will be 0.
+    *
+    * @param size This is the of the new element to write.
+    * @param additional_bytes The padding size.
+    */
+    public void prep(int size, int additional_bytes) {
+        // Track the biggest thing we've ever aligned to.
+        if (size > minalign) minalign = size;
+        // Find the amount of alignment needed such that `size` is properly
+        // aligned after `additional_bytes`
+        int align_size = ((~(bb.capacity() - space + additional_bytes)) + 1) & (size - 1);
+        // Reallocate the buffer if needed.
+        while (space < align_size + size + additional_bytes) {
+            int old_buf_size = bb.capacity();
+            ByteBuffer old = bb;
+            bb = growByteBuffer(old, bb_factory);
+            if (old != bb) {
+                bb_factory.releaseByteBuffer(old);
+            }
+            space += bb.capacity() - old_buf_size;
+        }
+        pad(align_size);
+    }
+
+    /**
+     * Add a `boolean` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x A `boolean` to put into the buffer.
+     */
+    public void putBoolean(boolean x) { bb.put      (space -= Constants.SIZEOF_BYTE, (byte)(x ? 1 : 0)); }
+
+    /**
+     * Add a `byte` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x A `byte` to put into the buffer.
+     */
+    public void putByte   (byte    x) { bb.put      (space -= Constants.SIZEOF_BYTE, x); }
+
+    /**
+     * Add a `short` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x A `short` to put into the buffer.
+     */
+    public void putShort  (short   x) { bb.putShort (space -= Constants.SIZEOF_SHORT, x); }
+
+    /**
+     * Add an `int` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x An `int` to put into the buffer.
+     */
+    public void putInt    (int     x) { bb.putInt   (space -= Constants.SIZEOF_INT, x); }
+
+    /**
+     * Add a `long` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x A `long` to put into the buffer.
+     */
+    public void putLong   (long    x) { bb.putLong  (space -= Constants.SIZEOF_LONG, x); }
+
+    /**
+     * Add a `float` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x A `float` to put into the buffer.
+     */
+    public void putFloat  (float   x) { bb.putFloat (space -= Constants.SIZEOF_FLOAT, x); }
+
+    /**
+     * Add a `double` to the buffer, backwards from the current location. Doesn't align nor
+     * check for space.
+     *
+     * @param x A `double` to put into the buffer.
+     */
+    public void putDouble (double  x) { bb.putDouble(space -= Constants.SIZEOF_DOUBLE, x); }
+    /// @endcond
+
+    /**
+     * Add a `boolean` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x A `boolean` to put into the buffer.
+     */
+    public void addBoolean(boolean x) { prep(Constants.SIZEOF_BYTE, 0); putBoolean(x); }
+
+    /**
+     * Add a `byte` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x A `byte` to put into the buffer.
+     */
+    public void addByte   (byte    x) { prep(Constants.SIZEOF_BYTE, 0); putByte   (x); }
+
+    /**
+     * Add a `short` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x A `short` to put into the buffer.
+     */
+    public void addShort  (short   x) { prep(Constants.SIZEOF_SHORT, 0); putShort  (x); }
+
+    /**
+     * Add an `int` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x An `int` to put into the buffer.
+     */
+    public void addInt    (int     x) { prep(Constants.SIZEOF_INT, 0); putInt    (x); }
+
+    /**
+     * Add a `long` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x A `long` to put into the buffer.
+     */
+    public void addLong   (long    x) { prep(Constants.SIZEOF_LONG, 0); putLong   (x); }
+
+    /**
+     * Add a `float` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x A `float` to put into the buffer.
+     */
+    public void addFloat  (float   x) { prep(Constants.SIZEOF_FLOAT, 0); putFloat  (x); }
+
+    /**
+     * Add a `double` to the buffer, properly aligned, and grows the buffer (if necessary).
+     *
+     * @param x A `double` to put into the buffer.
+     */
+    public void addDouble (double  x) { prep(Constants.SIZEOF_DOUBLE, 0); putDouble (x); }
+
+   /**
+    * Adds on offset, relative to where it will be written.
+    *
+    * @param off The offset to add.
+    */
+    public void addOffset(int off) {
+        prep(SIZEOF_INT, 0);  // Ensure alignment is already done.
+        assert off <= offset();
+        off = offset() - off + SIZEOF_INT;
+        putInt(off);
+    }
+
+   /// @cond FLATBUFFERS_INTERNAL
+   /**
+    * Start a new array/vector of objects.  Users usually will not call
+    * this directly.  The `FlatBuffers` compiler will create a start/end
+    * method for vector types in generated code.
+    * <p>
+    * The expected sequence of calls is:
+    * <ol>
+    * <li>Start the array using this method.</li>
+    * <li>Call {@link #addOffset(int)} `num_elems` number of times to set
+    * the offset of each element in the array.</li>
+    * <li>Call {@link #endVector()} to retrieve the offset of the array.</li>
+    * </ol>
+    * <p>
+    * For example, to create an array of strings, do:
+    * <pre>{@code
+    * // Need 10 strings
+    * FlatBufferBuilder builder = new FlatBufferBuilder(existingBuffer);
+    * int[] offsets = new int[10];
+    *
+    * for (int i = 0; i < 10; i++) {
+    *   offsets[i] = fbb.createString(" " + i);
+    * }
+    *
+    * // Have the strings in the buffer, but don't have a vector.
+    * // Add a vector that references the newly created strings:
+    * builder.startVector(4, offsets.length, 4);
+    *
+    * // Add each string to the newly created vector
+    * // The strings are added in reverse order since the buffer
+    * // is filled in back to front
+    * for (int i = offsets.length - 1; i >= 0; i--) {
+    *   builder.addOffset(offsets[i]);
+    * }
+    *
+    * // Finish off the vector
+    * int offsetOfTheVector = fbb.endVector();
+    * }</pre>
+    *
+    * @param elem_size The size of each element in the array.
+    * @param num_elems The number of elements in the array.
+    * @param alignment The alignment of the array.
+    */
+    public void startVector(int elem_size, int num_elems, int alignment) {
+        notNested();
+        vector_num_elems = num_elems;
+        prep(SIZEOF_INT, elem_size * num_elems);
+        prep(alignment, elem_size * num_elems); // Just in case alignment > int.
+        nested = true;
+    }
+
+   /**
+    * Finish off the creation of an array and all its elements.  The array
+    * must be created with {@link #startVector(int, int, int)}.
+    *
+    * @return The offset at which the newly created array starts.
+    * @see #startVector(int, int, int)
+    */
+    public int endVector() {
+        if (!nested)
+            throw new AssertionError("FlatBuffers: endVector called without startVector");
+        nested = false;
+        putInt(vector_num_elems);
+        return offset();
+    }
+    /// @endcond
+
+    /**
+     * Create a new array/vector and return a ByteBuffer to be filled later.
+     * Call {@link #endVector} after this method to get an offset to the beginning
+     * of vector.
+     *
+     * @param elem_size the size of each element in bytes.
+     * @param num_elems number of elements in the vector.
+     * @param alignment byte alignment.
+     * @return ByteBuffer with position and limit set to the space allocated for the array.
+     */
+    public ByteBuffer createUnintializedVector(int elem_size, int num_elems, int alignment) {
+        int length = elem_size * num_elems;
+        startVector(elem_size, num_elems, alignment);
+
+        bb.position(space -= length);
+
+        // Slice and limit the copy vector to point to the 'array'
+        ByteBuffer copy = bb.slice().order(ByteOrder.LITTLE_ENDIAN);
+        copy.limit(length);
+        return copy;
+    }
+
+   /**
+     * Create a vector of tables.
+     *
+     * @param offsets Offsets of the tables.
+     * @return Returns offset of the vector.
+     */
+    public int createVectorOfTables(int[] offsets) {
+        notNested();
+        startVector(Constants.SIZEOF_INT, offsets.length, Constants.SIZEOF_INT);
+        for(int i = offsets.length - 1; i >= 0; i--) addOffset(offsets[i]);
+        return endVector();
+    }
+
+    /**
+     * Create a vector of sorted by the key tables.
+     *
+     * @param obj Instance of the table subclass.
+     * @param offsets Offsets of the tables.
+     * @return Returns offset of the sorted vector.
+     */
+    public <T extends Table> int createSortedVectorOfTables(T obj, int[] offsets) {
+        obj.sortTables(offsets, bb);
+        return createVectorOfTables(offsets);
+    }
+
+    /**
+    * Encode the String `s` in the buffer using UTF-8. If a String with
+    * this exact contents has already been serialized using this method,
+    * instead simply returns the offset of the existing String.
+    *
+    * Usage of the method will incur into additional allocations,
+    * so it is advisable to use it only when it is known upfront that
+    * your message will have several repeated strings.
+    *
+    * @param s The String to encode.
+    * @return The offset in the buffer where the encoded String starts.
+    */
+    public int createSharedString(String s) {
+
+        if (string_pool == null) {
+            string_pool = new HashMap<>();
+            int offset = createString(s);
+            string_pool.put(s, offset);
+            return offset;
+
+        }
+
+        Integer offset = string_pool.get(s);
+
+        if(offset == null) {
+            offset = createString(s);
+            string_pool.put(s, offset);
+        }
+        return offset;
+    }
+
+   /**
+    * Encode the string `s` in the buffer using UTF-8.  If {@code s} is
+    * already a {@link CharBuffer}, this method is allocation free.
+    *
+    * @param s The string to encode.
+    * @return The offset in the buffer where the encoded string starts.
+    */
+    public int createString(CharSequence s) {
+        int length = utf8.encodedLength(s);
+        addByte((byte)0);
+        startVector(1, length, 1);
+        bb.position(space -= length);
+        utf8.encodeUtf8(s, bb);
+        return endVector();
+    }
+
+   /**
+    * Create a string in the buffer from an already encoded UTF-8 string in a ByteBuffer.
+    *
+    * @param s An already encoded UTF-8 string as a `ByteBuffer`.
+    * @return The offset in the buffer where the encoded string starts.
+    */
+    public int createString(ByteBuffer s) {
+        int length = s.remaining();
+        addByte((byte)0);
+        startVector(1, length, 1);
+        bb.position(space -= length);
+        bb.put(s);
+        return endVector();
+    }
+
+    /**
+     * Create a byte array in the buffer.
+     *
+     * @param arr A source array with data
+     * @return The offset in the buffer where the encoded array starts.
+     */
+    public int createByteVector(byte[] arr) {
+        int length = arr.length;
+        startVector(1, length, 1);
+        bb.position(space -= length);
+        bb.put(arr);
+        return endVector();
+    }
+
+    /**
+     * Create a byte array in the buffer.
+     *
+     * @param arr a source array with data.
+     * @param offset the offset in the source array to start copying from.
+     * @param length the number of bytes to copy from the source array.
+     * @return The offset in the buffer where the encoded array starts.
+     */
+    public int createByteVector(byte[] arr, int offset, int length) {
+        startVector(1, length, 1);
+        bb.position(space -= length);
+        bb.put(arr, offset, length);
+        return endVector();
+    }
+
+    /**
+     * Create a byte array in the buffer.
+     *
+     * The source {@link ByteBuffer} position is advanced by {@link ByteBuffer#remaining()} places
+     * after this call.
+     *
+     * @param byteBuffer A source {@link ByteBuffer} with data.
+     * @return The offset in the buffer where the encoded array starts.
+     */
+    public int createByteVector(ByteBuffer byteBuffer) {
+        int length = byteBuffer.remaining();
+        startVector(1, length, 1);
+        bb.position(space -= length);
+        bb.put(byteBuffer);
+        return endVector();
+    }
+
+   /// @cond FLATBUFFERS_INTERNAL
+   /**
+    * Should not be accessing the final buffer before it is finished.
+    */
+    public void finished() {
+        if (!finished)
+            throw new AssertionError(
+                "FlatBuffers: you can only access the serialized buffer after it has been" +
+                " finished by FlatBufferBuilder.finish().");
+    }
+
+   /**
+    * Should not be creating any other object, string or vector
+    * while an object is being constructed.
+    */
+    public void notNested() {
+        if (nested)
+            throw new AssertionError("FlatBuffers: object serialization must not be nested.");
+    }
+
+   /**
+    * Structures are always stored inline, they need to be created right
+    * where they're used.  You'll get this assertion failure if you
+    * created it elsewhere.
+    *
+    * @param obj The offset of the created object.
+    */
+    public void Nested(int obj) {
+        if (obj != offset())
+            throw new AssertionError("FlatBuffers: struct must be serialized inline.");
+    }
+
+   /**
+    * Start encoding a new object in the buffer.  Users will not usually need to
+    * call this directly. The `FlatBuffers` compiler will generate helper methods
+    * that call this method internally.
+    * <p>
+    * For example, using the "Monster" code found on the "landing page". An
+    * object of type `Monster` can be created using the following code:
+    *
+    * <pre>{@code
+    * int testArrayOfString = Monster.createTestarrayofstringVector(fbb, new int[] {
+    *   fbb.createString("test1"),
+    *   fbb.createString("test2")
+    * });
+    *
+    * Monster.startMonster(fbb);
+    * Monster.addPos(fbb, Vec3.createVec3(fbb, 1.0f, 2.0f, 3.0f, 3.0,
+    *   Color.Green, (short)5, (byte)6));
+    * Monster.addHp(fbb, (short)80);
+    * Monster.addName(fbb, str);
+    * Monster.addInventory(fbb, inv);
+    * Monster.addTestType(fbb, (byte)Any.Monster);
+    * Monster.addTest(fbb, mon2);
+    * Monster.addTest4(fbb, test4);
+    * Monster.addTestarrayofstring(fbb, testArrayOfString);
+    * int mon = Monster.endMonster(fbb);
+    * }</pre>
+    * <p>
+    * Here:
+    * <ul>
+    * <li>The call to `Monster#startMonster(FlatBufferBuilder)` will call this
+    * method with the right number of fields set.</li>
+    * <li>`Monster#endMonster(FlatBufferBuilder)` will ensure {@link #endObject()} is called.</li>
+    * </ul>
+    * <p>
+    * It's not recommended to call this method directly.  If it's called manually, you must ensure
+    * to audit all calls to it whenever fields are added or removed from your schema.  This is
+    * automatically done by the code generated by the `FlatBuffers` compiler.
+    *
+    * @param numfields The number of fields found in this object.
+    */
+    public void startTable(int numfields) {
+        notNested();
+        if (vtable == null || vtable.length < numfields) vtable = new int[numfields];
+        vtable_in_use = numfields;
+        Arrays.fill(vtable, 0, vtable_in_use, 0);
+        nested = true;
+        object_start = offset();
+    }
+
+    /**
+     * Add a `boolean` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x A `boolean` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d A `boolean` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addBoolean(int o, boolean x, boolean d) { if(force_defaults || x != d) { addBoolean(x); slot(o); } }
+
+    /**
+     * Add a `byte` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x A `byte` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d A `byte` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addByte   (int o, byte    x, int     d) { if(force_defaults || x != d) { addByte   (x); slot(o); } }
+
+    /**
+     * Add a `short` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x A `short` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d A `short` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addShort  (int o, short   x, int     d) { if(force_defaults || x != d) { addShort  (x); slot(o); } }
+
+    /**
+     * Add an `int` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x An `int` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d An `int` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addInt    (int o, int     x, int     d) { if(force_defaults || x != d) { addInt    (x); slot(o); } }
+
+    /**
+     * Add a `long` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x A `long` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d A `long` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addLong   (int o, long    x, long    d) { if(force_defaults || x != d) { addLong   (x); slot(o); } }
+
+    /**
+     * Add a `float` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x A `float` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d A `float` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addFloat  (int o, float   x, double  d) { if(force_defaults || x != d) { addFloat  (x); slot(o); } }
+
+    /**
+     * Add a `double` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x A `double` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d A `double` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addDouble (int o, double  x, double  d) { if(force_defaults || x != d) { addDouble (x); slot(o); } }
+
+    /**
+     * Add an `offset` to a table at `o` into its vtable, with value `x` and default `d`.
+     *
+     * @param o The index into the vtable.
+     * @param x An `offset` to put into the buffer, depending on how defaults are handled. If
+     * `force_defaults` is `false`, compare `x` against the default value `d`. If `x` contains the
+     * default value, it can be skipped.
+     * @param d An `offset` default value to compare against when `force_defaults` is `false`.
+     */
+    public void addOffset (int o, int     x, int     d) { if(force_defaults || x != d) { addOffset (x); slot(o); } }
+
+    /**
+     * Add a struct to the table. Structs are stored inline, so nothing additional is being added.
+     *
+     * @param voffset The index into the vtable.
+     * @param x The offset of the created struct.
+     * @param d The default value is always `0`.
+     */
+    public void addStruct(int voffset, int x, int d) {
+        if(x != d) {
+            Nested(x);
+            slot(voffset);
+        }
+    }
+
+    /**
+     * Set the current vtable at `voffset` to the current location in the buffer.
+     *
+     * @param voffset The index into the vtable to store the offset relative to the end of the
+     * buffer.
+     */
+    public void slot(int voffset) {
+        vtable[voffset] = offset();
+    }
+
+   /**
+    * Finish off writing the object that is under construction.
+    *
+    * @return The offset to the object inside {@link #dataBuffer()}.
+    * @see #startTable(int)
+    */
+    public int endTable() {
+        if (vtable == null || !nested)
+            throw new AssertionError("FlatBuffers: endTable called without startTable");
+        addInt(0);
+        int vtableloc = offset();
+        // Write out the current vtable.
+        int i = vtable_in_use - 1;
+        // Trim trailing zeroes.
+        for (; i >= 0 && vtable[i] == 0; i--) {}
+        int trimmed_size = i + 1;
+        for (; i >= 0 ; i--) {
+            // Offset relative to the start of the table.
+            short off = (short)(vtable[i] != 0 ? vtableloc - vtable[i] : 0);
+            addShort(off);
+        }
+
+        final int standard_fields = 2; // The fields below:
+        addShort((short)(vtableloc - object_start));
+        addShort((short)((trimmed_size + standard_fields) * SIZEOF_SHORT));
+
+        // Search for an existing vtable that matches the current one.
+        int existing_vtable = 0;
+        outer_loop:
+        for (i = 0; i < num_vtables; i++) {
+            int vt1 = bb.capacity() - vtables[i];
+            int vt2 = space;
+            short len = bb.getShort(vt1);
+            if (len == bb.getShort(vt2)) {
+                for (int j = SIZEOF_SHORT; j < len; j += SIZEOF_SHORT) {
+                    if (bb.getShort(vt1 + j) != bb.getShort(vt2 + j)) {
+                        continue outer_loop;
+                    }
+                }
+                existing_vtable = vtables[i];
+                break outer_loop;
+            }
+        }
+
+        if (existing_vtable != 0) {
+            // Found a match:
+            // Remove the current vtable.
+            space = bb.capacity() - vtableloc;
+            // Point table to existing vtable.
+            bb.putInt(space, existing_vtable - vtableloc);
+        } else {
+            // No match:
+            // Add the location of the current vtable to the list of vtables.
+            if (num_vtables == vtables.length) vtables = Arrays.copyOf(vtables, num_vtables * 2);
+            vtables[num_vtables++] = offset();
+            // Point table to current vtable.
+            bb.putInt(bb.capacity() - vtableloc, offset() - vtableloc);
+        }
+
+        nested = false;
+        return vtableloc;
+    }
+
+    /**
+     * Checks that a required field has been set in a given table that has
+     * just been constructed.
+     *
+     * @param table The offset to the start of the table from the `ByteBuffer` capacity.
+     * @param field The offset to the field in the vtable.
+     */
+    public void required(int table, int field) {
+        int table_start = bb.capacity() - table;
+        int vtable_start = table_start - bb.getInt(table_start);
+        boolean ok = bb.getShort(vtable_start + field) != 0;
+        // If this fails, the caller will show what field needs to be set.
+        if (!ok)
+            throw new AssertionError("FlatBuffers: field " + field + " must be set");
+    }
+    /// @endcond
+
+    /**
+     * Finalize a buffer, pointing to the given `root_table`.
+     *
+     * @param root_table An offset to be added to the buffer.
+     * @param size_prefix Whether to prefix the size to the buffer.
+     */
+    protected void finish(int root_table, boolean size_prefix) {
+        prep(minalign, SIZEOF_INT + (size_prefix ? SIZEOF_INT : 0));
+        addOffset(root_table);
+        if (size_prefix) {
+            addInt(bb.capacity() - space);
+        }
+        bb.position(space);
+        finished = true;
+    }
+
+    /**
+     * Finalize a buffer, pointing to the given `root_table`.
+     *
+     * @param root_table An offset to be added to the buffer.
+     */
+    public void finish(int root_table) {
+        finish(root_table, false);
+    }
+
+    /**
+     * Finalize a buffer, pointing to the given `root_table`, with the size prefixed.
+     *
+     * @param root_table An offset to be added to the buffer.
+     */
+    public void finishSizePrefixed(int root_table) {
+        finish(root_table, true);
+    }
+
+    /**
+     * Finalize a buffer, pointing to the given `root_table`.
+     *
+     * @param root_table An offset to be added to the buffer.
+     * @param file_identifier A FlatBuffer file identifier to be added to the buffer before
+     * `root_table`.
+     * @param size_prefix Whether to prefix the size to the buffer.
+     */
+    protected void finish(int root_table, String file_identifier, boolean size_prefix) {
+        prep(minalign, SIZEOF_INT + FILE_IDENTIFIER_LENGTH + (size_prefix ? SIZEOF_INT : 0));
+        if (file_identifier.length() != FILE_IDENTIFIER_LENGTH)
+            throw new AssertionError("FlatBuffers: file identifier must be length " +
+                                     FILE_IDENTIFIER_LENGTH);
+        for (int i = FILE_IDENTIFIER_LENGTH - 1; i >= 0; i--) {
+            addByte((byte)file_identifier.charAt(i));
+        }
+        finish(root_table, size_prefix);
+    }
+
+    /**
+     * Finalize a buffer, pointing to the given `root_table`.
+     *
+     * @param root_table An offset to be added to the buffer.
+     * @param file_identifier A FlatBuffer file identifier to be added to the buffer before
+     * `root_table`.
+     */
+    public void finish(int root_table, String file_identifier) {
+        finish(root_table, file_identifier, false);
+    }
+
+    /**
+     * Finalize a buffer, pointing to the given `root_table`, with the size prefixed.
+     *
+     * @param root_table An offset to be added to the buffer.
+     * @param file_identifier A FlatBuffer file identifier to be added to the buffer before
+     * `root_table`.
+     */
+    public void finishSizePrefixed(int root_table, String file_identifier) {
+        finish(root_table, file_identifier, true);
+    }
+
+    /**
+     * In order to save space, fields that are set to their default value
+     * don't get serialized into the buffer. Forcing defaults provides a
+     * way to manually disable this optimization.
+     *
+     * @param forceDefaults When set to `true`, always serializes default values.
+     * @return Returns `this`.
+     */
+    public FlatBufferBuilder forceDefaults(boolean forceDefaults){
+        this.force_defaults = forceDefaults;
+        return this;
+    }
+
+    /**
+     * Get the ByteBuffer representing the FlatBuffer. Only call this after you've
+     * called `finish()`. The actual data starts at the ByteBuffer's current position,
+     * not necessarily at `0`.
+     *
+     * @return The {@link ByteBuffer} representing the FlatBuffer
+     */
+    public ByteBuffer dataBuffer() {
+        finished();
+        return bb;
+    }
+
+   /**
+    * The FlatBuffer data doesn't start at offset 0 in the {@link ByteBuffer}, but
+    * now the {@code ByteBuffer}'s position is set to that location upon {@link #finish(int)}.
+    *
+    * @return The {@link ByteBuffer#position() position} the data starts in {@link #dataBuffer()}
+    * @deprecated This method should not be needed anymore, but is left
+    * here for the moment to document this API change. It will be removed in the future.
+    */
+    @Deprecated
+    private int dataStart() {
+        finished();
+        return space;
+    }
+
+   /**
+    * A utility function to copy and return the ByteBuffer data from `start` to
+    * `start` + `length` as a `byte[]`.
+    *
+    * @param start Start copying at this offset.
+    * @param length How many bytes to copy.
+    * @return A range copy of the {@link #dataBuffer() data buffer}.
+    * @throws IndexOutOfBoundsException If the range of bytes is ouf of bound.
+    */
+    public byte[] sizedByteArray(int start, int length){
+        finished();
+        byte[] array = new byte[length];
+        bb.position(start);
+        bb.get(array);
+        return array;
+    }
+
+   /**
+    * A utility function to copy and return the ByteBuffer data as a `byte[]`.
+    *
+    * @return A full copy of the {@link #dataBuffer() data buffer}.
+    */
+    public byte[] sizedByteArray() {
+        return sizedByteArray(space, bb.capacity() - space);
+    }
+
+    /**
+     * A utility function to return an InputStream to the ByteBuffer data
+     *
+     * @return An InputStream that starts at the beginning of the ByteBuffer data
+     *         and can read to the end of it.
+     */
+    public InputStream sizedInputStream() {
+        finished();
+        ByteBuffer duplicate = bb.duplicate();
+        duplicate.position(space);
+        duplicate.limit(bb.capacity());
+        return new ByteBufferBackedInputStream(duplicate);
+    }
+
+    /**
+     * A class that allows a user to create an InputStream from a ByteBuffer.
+     */
+    static class ByteBufferBackedInputStream extends InputStream {
+
+        ByteBuffer buf;
+
+        public ByteBufferBackedInputStream(ByteBuffer buf) {
+            this.buf = buf;
+        }
+
+        public int read() throws IOException {
+            try {
+                return buf.get() & 0xFF;
+            } catch(BufferUnderflowException e) {
+                return -1;
+            }
+        }
+    }
+
+}
+
+/// @}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffers.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffers.java
new file mode 100644
index 00000000..1dfbb8ca
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffers.java
@@ -0,0 +1,1221 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+
+import static io.objectbox.flatbuffers.FlexBuffers.Unsigned.byteToUnsignedInt;
+import static io.objectbox.flatbuffers.FlexBuffers.Unsigned.intToUnsignedLong;
+import static io.objectbox.flatbuffers.FlexBuffers.Unsigned.shortToUnsignedInt;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.charset.StandardCharsets;
+
+/// @file
+/// @addtogroup flatbuffers_java_api
+/// @{
+
+/**
+ * This class can be used to parse FlexBuffer messages.
+ * <p>
+ * For generating FlexBuffer messages, use {@link FlexBuffersBuilder}.
+ * <p>
+ * Example of usage:
+ * <pre>
+ * ReadBuf bb = ... // load message from file or network
+ * FlexBuffers.Reference r = FlexBuffers.getRoot(bb); // Reads the root element
+ * FlexBuffers.Map map = r.asMap(); // We assumed root object is a map
+ * System.out.println(map.get("name").asString()); // prints element with key "name"
+ * </pre>
+ */
+public class FlexBuffers {
+
+    // These are used as the upper 6 bits of a type field to indicate the actual
+    // type.
+    /** Represent a null type */
+    public static final int FBT_NULL = 0;
+    /** Represent a signed integer type */
+    public static final int FBT_INT = 1;
+    /** Represent a unsigned type */
+    public static final int FBT_UINT = 2;
+    /** Represent a float type */
+    public static final int FBT_FLOAT = 3; // Types above stored inline, types below store an offset.
+    /** Represent a key to a map type */
+    public static final int FBT_KEY = 4;
+    /** Represent a string type */
+    public static final int FBT_STRING = 5;
+    /** Represent a indirect signed integer type */
+    public static final int FBT_INDIRECT_INT = 6;
+    /** Represent a indirect unsigned integer type */
+    public static final int FBT_INDIRECT_UINT = 7;
+    /** Represent a indirect float type */
+    public static final int FBT_INDIRECT_FLOAT = 8;
+    /** Represent a map type */
+    public static final int FBT_MAP = 9;
+    /** Represent a vector type */
+    public static final int FBT_VECTOR = 10; // Untyped.
+    /** Represent a vector of signed integers type */
+    public static final int FBT_VECTOR_INT = 11;  // Typed any size  = stores no type table).
+    /** Represent a vector of unsigned integers type */
+    public static final int FBT_VECTOR_UINT = 12;
+    /** Represent a vector of floats type */
+    public static final int FBT_VECTOR_FLOAT = 13;
+    /** Represent a vector of keys type */
+    public static final int FBT_VECTOR_KEY = 14;
+    /** Represent a vector of strings type */
+    // DEPRECATED, use FBT_VECTOR or FBT_VECTOR_KEY instead.
+    // more info on thttps://github.com/google/flatbuffers/issues/5627.
+    public static final int FBT_VECTOR_STRING_DEPRECATED = 15;
+
+    /// @cond FLATBUFFERS_INTERNAL
+    public static final int FBT_VECTOR_INT2 = 16;  // Typed tuple  = no type table; no size field).
+    public static final int FBT_VECTOR_UINT2 = 17;
+    public static final int FBT_VECTOR_FLOAT2 = 18;
+    public static final int FBT_VECTOR_INT3 = 19;  // Typed triple  = no type table; no size field).
+    public static final int FBT_VECTOR_UINT3 = 20;
+    public static final int FBT_VECTOR_FLOAT3 = 21;
+    public static final int FBT_VECTOR_INT4 = 22;  // Typed quad  = no type table; no size field).
+    public static final int FBT_VECTOR_UINT4 = 23;
+    public static final int FBT_VECTOR_FLOAT4 = 24;
+    /// @endcond FLATBUFFERS_INTERNAL
+
+    /** Represent a blob type */
+    public static final int FBT_BLOB = 25;
+    /** Represent a boolean type */
+    public static final int FBT_BOOL = 26;
+    /** Represent a vector of booleans type */
+    public static final int FBT_VECTOR_BOOL = 36;  // To Allow the same type of conversion of type to vector type
+
+    private static final ReadBuf EMPTY_BB = new ArrayReadWriteBuf(new byte[] {0}, 1);
+
+    /**
+     * Checks where a type is a typed vector
+     *
+     * @param type type to be checked
+     * @return true if typed vector
+     */
+    static boolean isTypedVector(int type) {
+        return (type >= FBT_VECTOR_INT && type <= FBT_VECTOR_STRING_DEPRECATED) || type == FBT_VECTOR_BOOL;
+    }
+
+    /**
+     * Check whether you can access type directly (no indirection) or not.
+     *
+     * @param type type to be checked
+     * @return true if inline type
+     */
+    static boolean isTypeInline(int type) {
+        return type <= FBT_FLOAT || type == FBT_BOOL;
+    }
+
+    static int toTypedVectorElementType(int original_type) {
+        return original_type - FBT_VECTOR_INT + FBT_INT;
+    }
+
+    /**
+     * Return a vector type our of a original element type
+     *
+     * @param type        element type
+     * @param fixedLength size of element
+     * @return typed vector type
+     */
+    static int toTypedVector(int type, int fixedLength) {
+        assert (isTypedVectorElementType(type));
+        switch (fixedLength) {
+            case 0: return type - FBT_INT + FBT_VECTOR_INT;
+            case 2: return type - FBT_INT + FBT_VECTOR_INT2;
+            case 3: return type - FBT_INT + FBT_VECTOR_INT3;
+            case 4: return type - FBT_INT + FBT_VECTOR_INT4;
+            default:
+                assert (false);
+                return FBT_NULL;
+        }
+    }
+
+    static boolean isTypedVectorElementType(int type) {
+        return (type >= FBT_INT && type <= FBT_KEY) || type == FBT_BOOL;
+    }
+
+    // return position of the element that the offset is pointing to
+    private static int indirect(ReadBuf bb, int offset, int byteWidth) {
+        // we assume all offset fits on a int, since ReadBuf operates with that assumption
+        return (int) (offset - readUInt(bb, offset, byteWidth));
+    }
+
+    // read unsigned int with size byteWidth and return as a 64-bit integer
+    private static long readUInt(ReadBuf buff, int end, int byteWidth) {
+        switch (byteWidth) {
+            case 1: return byteToUnsignedInt(buff.get(end));
+            case 2: return shortToUnsignedInt(buff.getShort(end));
+            case 4: return intToUnsignedLong(buff.getInt(end));
+            case 8: return buff.getLong(end); // We are passing signed long here. Losing information (user should know)
+            default: return -1; // we should never reach here
+        }
+    }
+
+    // read signed int of size byteWidth and return as 32-bit int
+    private static int readInt(ReadBuf buff, int end, int byteWidth) {
+        return (int) readLong(buff, end, byteWidth);
+    }
+
+    // read signed int of size byteWidth and return as 64-bit int
+    private static long readLong(ReadBuf buff, int end, int byteWidth) {
+        switch (byteWidth) {
+            case 1: return buff.get(end);
+            case 2: return buff.getShort(end);
+            case 4: return buff.getInt(end);
+            case 8: return buff.getLong(end);
+            default: return -1; // we should never reach here
+        }
+    }
+
+    private static double readDouble(ReadBuf buff, int end, int byteWidth) {
+        switch (byteWidth) {
+            case 4: return buff.getFloat(end);
+            case 8: return buff.getDouble(end);
+            default: return -1; // we should never reach here
+        }
+    }
+
+    /**
+     * Reads a FlexBuffer message in ReadBuf and returns {@link Reference} to
+     * the root element.
+     * @param buffer ReadBuf containing FlexBuffer message
+     * @return {@link Reference} to the root object
+     */
+    @Deprecated
+    public static Reference getRoot(ByteBuffer buffer) {
+        return getRoot( buffer.hasArray() ? new ArrayReadWriteBuf(buffer.array(), buffer.limit()) : new ByteBufferReadWriteBuf(buffer));
+    }
+
+        /**
+     * Reads a FlexBuffer message in ReadBuf and returns {@link Reference} to
+     * the root element.
+     * @param buffer ReadBuf containing FlexBuffer message
+     * @return {@link Reference} to the root object
+     */
+    public static Reference getRoot(ReadBuf buffer) {
+        // See Finish() below for the serialization counterpart of this.
+        // The root ends at the end of the buffer, so we parse backwards from there.
+        int end = buffer.limit();
+        int byteWidth = buffer.get(--end);
+        int packetType = byteToUnsignedInt(buffer.get(--end));
+        end -= byteWidth;  // The root data item.
+        return new Reference(buffer, end, byteWidth, packetType);
+    }
+
+    /**
+     * Represents an generic element in the buffer.
+     */
+    public static class Reference {
+
+        private static final Reference NULL_REFERENCE = new Reference(EMPTY_BB, 0, 1, 0);
+        private ReadBuf bb;
+        private int end;
+        private int parentWidth;
+        private int byteWidth;
+        private int type;
+
+        Reference(ReadBuf bb, int end, int parentWidth, int packedType) {
+            this(bb, end, parentWidth, (1 << (packedType & 3)), packedType >> 2);
+        }
+
+        Reference(ReadBuf bb, int end, int parentWidth, int byteWidth, int type) {
+            this.bb = bb;
+            this.end = end;
+            this.parentWidth = parentWidth;
+            this.byteWidth = byteWidth;
+            this.type = type;
+        }
+
+        /**
+         * Return element type
+         * @return element type as integer
+         */
+        public int getType() {
+            return type;
+        }
+
+        /**
+         * Checks whether the element is null type
+         * @return true if null type
+         */
+        public boolean isNull() {
+            return type == FBT_NULL;
+        }
+
+        /**
+         * Checks whether the element is boolean type
+         * @return true if boolean type
+         */
+        public boolean isBoolean() {
+            return type == FBT_BOOL;
+        }
+
+        /**
+         * Checks whether the element type is numeric (signed/unsigned integers and floats)
+         * @return true if numeric type
+         */
+        public boolean isNumeric() {
+            return isIntOrUInt() || isFloat();
+        }
+
+        /**
+         * Checks whether the element type is signed or unsigned integers
+         * @return true if an integer type
+         */
+        public boolean isIntOrUInt() {
+            return isInt() || isUInt();
+        }
+
+        /**
+         * Checks whether the element type is float
+         * @return true if a float type
+         */
+        public boolean isFloat() {
+            return type == FBT_FLOAT || type == FBT_INDIRECT_FLOAT;
+        }
+
+        /**
+         * Checks whether the element type is signed integer
+         * @return true if a signed integer type
+         */
+        public boolean isInt() {
+            return type == FBT_INT || type == FBT_INDIRECT_INT;
+        }
+
+        /**
+         * Checks whether the element type is signed integer
+         * @return true if a signed integer type
+         */
+        public boolean isUInt() {
+            return type == FBT_UINT || type == FBT_INDIRECT_UINT;
+        }
+
+        /**
+         * Checks whether the element type is string
+         * @return true if a string type
+         */
+        public boolean isString() {
+            return type == FBT_STRING;
+        }
+
+        /**
+         * Checks whether the element type is key
+         * @return true if a key type
+         */
+        public boolean isKey() {
+            return type == FBT_KEY;
+        }
+
+        /**
+         * Checks whether the element type is vector
+         * @return true if a vector type
+         */
+        public boolean isVector() {
+            return type == FBT_VECTOR || type == FBT_MAP;
+        }
+
+        /**
+         * Checks whether the element type is typed vector
+         * @return true if a typed vector type
+         */
+        public boolean isTypedVector() {
+            return FlexBuffers.isTypedVector(type);
+        }
+
+        /**
+         * Checks whether the element type is a map
+         * @return true if a map type
+         */
+        public boolean isMap() {
+            return type == FBT_MAP;
+        }
+
+        /**
+         * Checks whether the element type is a blob
+         * @return true if a blob type
+         */
+        public boolean isBlob() {
+            return type == FBT_BLOB;
+        }
+
+        /**
+         * Returns element as 32-bit integer.
+         * <p> For vector element, it will return size of the vector</p>
+         * <p> For String element, it will type to be parsed as integer</p>
+         * <p> Unsigned elements will become negative</p>
+         * <p> Float elements will be casted to integer </p>
+         * @return 32-bit integer or 0 if fail to convert element to integer.
+         */
+        public int asInt() {
+            if (type == FBT_INT) {
+                // A fast path for the common case.
+                return readInt(bb, end, parentWidth);
+            } else
+                switch (type) {
+                    case FBT_INDIRECT_INT: return readInt(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_UINT: return (int) readUInt(bb, end, parentWidth);
+                    case FBT_INDIRECT_UINT: return (int) readUInt(bb, indirect(bb, end, parentWidth), parentWidth);
+                    case FBT_FLOAT: return (int) readDouble(bb, end, parentWidth);
+                    case FBT_INDIRECT_FLOAT: return (int) readDouble(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_NULL: return 0;
+                    case FBT_STRING: return Integer.parseInt(asString());
+                    case FBT_VECTOR: return asVector().size();
+                    case FBT_BOOL: return readInt(bb, end, parentWidth);
+                    default:
+                        // Convert other things to int.
+                        return 0;
+                }
+        }
+
+        /**
+         * Returns element as unsigned 64-bit integer.
+         * <p> For vector element, it will return size of the vector</p>
+         * <p> For String element, it will type to be parsed as integer</p>
+         * <p> Negative signed elements will become unsigned counterpart</p>
+         * <p> Float elements will be casted to integer </p>
+         * @return 64-bit integer or 0 if fail to convert element to integer.
+         */
+        public long asUInt() {
+            if (type == FBT_UINT) {
+                // A fast path for the common case.
+                return readUInt(bb, end, parentWidth);
+            } else
+                switch (type) {
+                    case FBT_INDIRECT_UINT: return readUInt(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_INT: return readLong(bb, end, parentWidth);
+                    case FBT_INDIRECT_INT: return readLong(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_FLOAT: return (long) readDouble(bb, end, parentWidth);
+                    case FBT_INDIRECT_FLOAT: return (long) readDouble(bb,  indirect(bb, end, parentWidth), parentWidth);
+                    case FBT_NULL: return 0;
+                    case FBT_STRING: return Long.parseLong(asString());
+                    case FBT_VECTOR: return asVector().size();
+                    case FBT_BOOL: return readInt(bb, end, parentWidth);
+                    default:
+                        // Convert other things to uint.
+                        return 0;
+                }
+        }
+
+        /**
+         * Returns element as 64-bit integer.
+         * <p> For vector element, it will return size of the vector</p>
+         * <p> For String element, it will type to be parsed as integer</p>
+         * <p> Unsigned elements will become negative</p>
+         * <p> Float elements will be casted to integer </p>
+         * @return 64-bit integer or 0 if fail to convert element to long.
+         */
+        public long asLong() {
+            if (type == FBT_INT) {
+                // A fast path for the common case.
+                return readLong(bb, end, parentWidth);
+            } else
+                switch (type) {
+                    case FBT_INDIRECT_INT: return readLong(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_UINT: return readUInt(bb, end, parentWidth);
+                    case FBT_INDIRECT_UINT: return readUInt(bb, indirect(bb, end, parentWidth), parentWidth);
+                    case FBT_FLOAT: return (long) readDouble(bb, end, parentWidth);
+                    case FBT_INDIRECT_FLOAT: return (long) readDouble(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_NULL: return 0;
+                    case FBT_STRING: {
+                        try {
+                            return Long.parseLong(asString());
+                        } catch (NumberFormatException nfe) {
+                            return 0; //same as C++ implementation
+                        }
+                    }
+                    case FBT_VECTOR: return asVector().size();
+                    case FBT_BOOL: return readInt(bb, end, parentWidth);
+                    default:
+                        // Convert other things to int.
+                        return 0;
+                }
+        }
+
+        /**
+         * Returns element as 64-bit integer.
+         * <p> For vector element, it will return size of the vector</p>
+         * <p> For String element, it will type to be parsed as integer</p>
+         * @return 64-bit integer or 0 if fail to convert element to long.
+         */
+        public double asFloat() {
+            if (type == FBT_FLOAT) {
+                // A fast path for the common case.
+                return readDouble(bb, end, parentWidth);
+            } else
+                switch (type) {
+                    case FBT_INDIRECT_FLOAT: return readDouble(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_INT: return readInt(bb, end, parentWidth);
+                    case FBT_UINT:
+                    case FBT_BOOL:
+                        return readUInt(bb, end, parentWidth);
+                    case FBT_INDIRECT_INT: return readInt(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_INDIRECT_UINT: return readUInt(bb, indirect(bb, end, parentWidth), byteWidth);
+                    case FBT_NULL: return 0.0;
+                    case FBT_STRING: return Double.parseDouble(asString());
+                    case FBT_VECTOR: return asVector().size();
+                    default:
+                        // Convert strings and other things to float.
+                        return 0;
+                }
+        }
+
+        /**
+         * Returns element as a {@link Key}
+         * @return key or {@link Key#empty()} if element is not a key
+         */
+        public Key asKey() {
+            if (isKey()) {
+                return new Key(bb, indirect(bb, end, parentWidth), byteWidth);
+            } else {
+                return Key.empty();
+            }
+        }
+
+        /**
+         * Returns element as a `String`
+         * @return element as `String` or empty `String` if fail
+         */
+        public String asString() {
+            if (isString()) {
+                int start = indirect(bb, end, parentWidth);
+                int size = (int) readUInt(bb, start - byteWidth, byteWidth);
+                return bb.getString(start, size);
+            }
+            else if (isKey()){
+                int start = indirect(bb, end, byteWidth);
+                for (int i = start; ; i++) {
+                    if (bb.get(i) == 0) {
+                        return bb.getString(start, i - start);
+                    }
+                }
+            } else {
+                return "";
+            }
+        }
+
+        /**
+         * Returns element as a {@link Map}
+         * @return element as {@link Map} or empty {@link Map} if fail
+         */
+        public Map asMap() {
+            if (isMap()) {
+                return new Map(bb, indirect(bb, end, parentWidth), byteWidth);
+            } else {
+                return Map.empty();
+            }
+        }
+
+        /**
+         * Returns element as a {@link Vector}
+         * @return element as {@link Vector} or empty {@link Vector} if fail
+         */
+        public Vector asVector() {
+            if (isVector()) {
+                return new Vector(bb, indirect(bb, end, parentWidth), byteWidth);
+            } else if(type == FlexBuffers.FBT_VECTOR_STRING_DEPRECATED) {
+                // deprecated. Should be treated as key vector
+                return new TypedVector(bb, indirect(bb, end, parentWidth), byteWidth, FlexBuffers.FBT_KEY);
+            } else if (FlexBuffers.isTypedVector(type)) {
+                return new TypedVector(bb, indirect(bb, end, parentWidth), byteWidth, FlexBuffers.toTypedVectorElementType(type));
+            } else {
+                return Vector.empty();
+            }
+        }
+
+        /**
+         * Returns element as a {@link Blob}
+         * @return element as {@link Blob} or empty {@link Blob} if fail
+         */
+        public Blob asBlob() {
+            if (isBlob() || isString()) {
+                return new Blob(bb, indirect(bb, end, parentWidth), byteWidth);
+            } else {
+                return Blob.empty();
+            }
+        }
+
+        /**
+         * Returns element as a boolean
+         * <p>If element type is not boolean, it will be casted to integer and compared against 0</p>
+         * @return element as boolean
+         */
+        public boolean asBoolean() {
+            if (isBoolean()) {
+                return bb.get(end) != 0;
+            }
+            return asUInt() != 0;
+        }
+
+        /**
+         * Returns text representation of the element (JSON)
+         * @return String containing text representation of the element
+         */
+        @Override
+        public String toString() {
+            return toString(new StringBuilder(128)).toString();
+        }
+
+        /**
+         * Appends a text(JSON) representation to a `StringBuilder`
+         */
+        StringBuilder toString(StringBuilder sb) {
+            //TODO: Original C++ implementation escape strings.
+            // probably we should do it as well.
+            switch (type) {
+                case FBT_NULL:
+                    return sb.append("null");
+                case FBT_INT:
+                case FBT_INDIRECT_INT:
+                    return sb.append(asLong());
+                case FBT_UINT:
+                case FBT_INDIRECT_UINT:
+                    return sb.append(asUInt());
+                case FBT_INDIRECT_FLOAT:
+                case FBT_FLOAT:
+                    return sb.append(asFloat());
+                case FBT_KEY:
+                    return asKey().toString(sb.append('"')).append('"');
+                case FBT_STRING:
+                    return sb.append('"').append(asString()).append('"');
+                case FBT_MAP:
+                    return asMap().toString(sb);
+                case FBT_VECTOR:
+                    return asVector().toString(sb);
+                case FBT_BLOB:
+                    return asBlob().toString(sb);
+                case FBT_BOOL:
+                    return sb.append(asBoolean());
+                case FBT_VECTOR_INT:
+                case FBT_VECTOR_UINT:
+                case FBT_VECTOR_FLOAT:
+                case FBT_VECTOR_KEY:
+                case FBT_VECTOR_STRING_DEPRECATED:
+                case FBT_VECTOR_BOOL:
+                    return sb.append(asVector());
+                case FBT_VECTOR_INT2:
+                case FBT_VECTOR_UINT2:
+                case FBT_VECTOR_FLOAT2:
+                case FBT_VECTOR_INT3:
+                case FBT_VECTOR_UINT3:
+                case FBT_VECTOR_FLOAT3:
+                case FBT_VECTOR_INT4:
+                case FBT_VECTOR_UINT4:
+                case FBT_VECTOR_FLOAT4:
+
+                    throw new FlexBufferException("not_implemented:" + type);
+                default:
+                    return sb;
+            }
+        }
+    }
+
+    /**
+     * Base class of all types below.
+     * Points into the data buffer and allows access to one type.
+     */
+    private static abstract class Object {
+        ReadBuf bb;
+        int end;
+        int byteWidth;
+
+        Object(ReadBuf buff, int end, int byteWidth) {
+            this.bb = buff;
+            this.end = end;
+            this.byteWidth = byteWidth;
+        }
+
+        @Override
+        public String toString() {
+            return toString(new StringBuilder(128)).toString();
+        }
+
+        public abstract StringBuilder toString(StringBuilder sb);
+    }
+
+    // Stores size in `byte_width_` bytes before end position.
+    private static abstract class Sized extends Object {
+
+        protected final int size;
+
+        Sized(ReadBuf buff, int end, int byteWidth) {
+            super(buff, end, byteWidth);
+            size = (int) readUInt(bb, end - byteWidth, byteWidth);
+        }
+
+        public int size() {
+            return size;
+        }
+    }
+
+    /**
+     * Represents a array of bytes element in the buffer
+     *
+     * <p>It can be converted to `ReadBuf` using {@link data()},
+     * copied into a byte[] using {@link getBytes()} or
+     * have individual bytes accessed individually using {@link get(int)}</p>
+     */
+    public static class Blob extends Sized {
+        static final Blob EMPTY = new Blob(EMPTY_BB, 1, 1);
+
+        Blob(ReadBuf buff, int end, int byteWidth) {
+            super(buff, end, byteWidth);
+        }
+
+        /** Return an empty {@link Blob} */
+        public static Blob empty() {
+            return EMPTY;
+        }
+
+        /**
+         * Return {@link Blob} as `ReadBuf`
+         * @return blob as `ReadBuf`
+         */
+        public ByteBuffer data() {
+            ByteBuffer dup = ByteBuffer.wrap(bb.data());
+            dup.position(end);
+            dup.limit(end + size());
+            return dup.asReadOnlyBuffer().slice();
+        }
+
+        /**
+         * Copy blob into a byte[]
+         * @return blob as a byte[]
+         */
+        public byte[] getBytes() {
+            int size = size();
+            byte[] result = new byte[size];
+            for (int i = 0; i < size; i++) {
+                result[i] = bb.get(end + i);
+            }
+            return result;
+        }
+
+        /**
+         * Return individual byte at a given position
+         * @param pos position of the byte to be read
+         */
+        public byte get(int pos) {
+            assert pos >=0 && pos <= size();
+            return bb.get(end + pos);
+        }
+
+        /**
+         * Returns a text(JSON) representation of the {@link Blob}
+         */
+        @Override
+        public String toString() {
+            return bb.getString(end, size());
+        }
+
+        /**
+         * Append a text(JSON) representation of the {@link Blob} into a `StringBuilder`
+         */
+        @Override
+        public StringBuilder toString(StringBuilder sb) {
+            sb.append('"');
+            sb.append(bb.getString(end, size()));
+            return sb.append('"');
+        }
+    }
+
+    /**
+     * Represents a key element in the buffer. Keys are
+     * used to reference objects in a {@link Map}
+     */
+    public static class Key extends Object {
+
+        private static final Key EMPTY = new Key(EMPTY_BB, 0, 0);
+
+        Key(ReadBuf buff, int end, int byteWidth) {
+            super(buff, end, byteWidth);
+        }
+
+        /**
+         * Return an empty {@link Key}
+         * @return empty {@link Key}
+         * */
+        public static Key empty() {
+            return Key.EMPTY;
+        }
+
+        /**
+         * Appends a text(JSON) representation to a `StringBuilder`
+         */
+        @Override
+        public StringBuilder toString(StringBuilder sb) {
+            return sb.append(toString());
+        }
+
+        @Override
+        public String toString() {
+            int size;
+            for (int i = end; ; i++) {
+                if (bb.get(i) == 0) {
+                    size = i - end;
+                    break;
+                }
+            }
+            return bb.getString(end, size);
+        }
+
+        int compareTo(byte[] other) {
+            int ia = end;
+            int io = 0;
+            byte c1, c2;
+            do {
+                c1 = bb.get(ia);
+                c2 = other[io];
+                if (c1 == '\0')
+                    return c1 - c2;
+                ia++;
+                io++;
+                if (io == other.length) {
+                    // in our buffer we have an additional \0 byte
+                    // but this does not exist in regular Java strings, so we return now
+                    int cmp = c1 - c2;
+                    if (cmp != 0 || bb.get(ia) == '\0') {
+                        return cmp;
+                    } else {
+                        return 1;
+                    }
+                }
+            }
+            while (c1 == c2);
+            return c1 - c2;
+        }
+
+        /**
+         *  Compare keys
+         *  @param obj other key to compare
+         *  @return true if keys are the same
+         */
+        @Override
+        public boolean equals(java.lang.Object obj) {
+            if (!(obj instanceof Key))
+                return false;
+
+            return ((Key) obj).end == end && ((Key) obj).byteWidth == byteWidth;
+        }
+
+        public int hashCode() {
+          return end ^ byteWidth;
+        }
+    }
+
+    /**
+     * Map object representing a set of key-value pairs.
+     */
+    public static class Map extends Vector {
+        private static final Map EMPTY_MAP = new Map(EMPTY_BB, 1, 1);
+        // cache for converting UTF-8 codepoints into
+        // Java chars. Used to speed up String comparison
+        private final byte[] comparisonBuffer = new byte[4];
+
+        Map(ReadBuf bb, int end, int byteWidth) {
+            super(bb, end, byteWidth);
+        }
+
+        /**
+         * Returns an empty {@link Map}
+         * @return an empty {@link Map}
+         */
+        public static Map empty() {
+            return EMPTY_MAP;
+        }
+
+        /**
+         * @param key access key to element on map
+         * @return reference to value in map
+         */
+        public Reference get(String key) {
+            int index = binarySearch(key);
+            if (index >= 0 && index < size) {
+                return get(index);
+            }
+            return Reference.NULL_REFERENCE;
+        }
+
+        /**
+         * @param key access key to element on map. Keys are assumed to be encoded in UTF-8
+         * @return reference to value in map
+         */
+        public Reference get(byte[] key) {
+            int index = binarySearch(key);
+            if (index >= 0 && index < size) {
+                return get(index);
+            }
+            return Reference.NULL_REFERENCE;
+        }
+
+        /**
+         * Get a vector or keys in the map
+         *
+         * @return vector of keys
+         */
+        public KeyVector keys() {
+            final int num_prefixed_fields = 3;
+            int keysOffset = end - (byteWidth * num_prefixed_fields);
+            return new KeyVector(new TypedVector(bb,
+                    indirect(bb, keysOffset, byteWidth),
+                    readInt(bb, keysOffset + byteWidth, byteWidth),
+                    FBT_KEY));
+        }
+
+        /**
+         * @return {@code Vector} of values from map
+         */
+        public Vector values() {
+            return new Vector(bb, end, byteWidth);
+        }
+
+        /**
+         * Writes text (json) representation of map in a {@code StringBuilder}.
+         *
+         * @param builder {@code StringBuilder} to be appended to
+         * @return Same {@code StringBuilder} with appended text
+         */
+        public StringBuilder toString(StringBuilder builder) {
+            builder.append("{ ");
+            KeyVector keys = keys();
+            int size = size();
+            Vector vals = values();
+            for (int i = 0; i < size; i++) {
+                builder.append('"')
+                        .append(keys.get(i).toString())
+                        .append("\" : ");
+                builder.append(vals.get(i).toString());
+                if (i != size - 1)
+                    builder.append(", ");
+            }
+            builder.append(" }");
+            return builder;
+        }
+
+        // Performs a binary search on a key vector and return index of the key in key vector
+        private int binarySearch(CharSequence searchedKey) {
+            int low = 0;
+            int high = size - 1;
+            final int num_prefixed_fields = 3;
+            int keysOffset = end - (byteWidth * num_prefixed_fields);
+            int keysStart = indirect(bb, keysOffset, byteWidth);
+            int keyByteWidth = readInt(bb, keysOffset + byteWidth, byteWidth);
+            while (low <= high) {
+                int mid = (low + high) >>> 1;
+                int keyPos = indirect(bb, keysStart + mid * keyByteWidth, keyByteWidth);
+                int cmp = compareCharSequence(keyPos, searchedKey);
+                if (cmp < 0)
+                    low = mid + 1;
+                else if (cmp > 0)
+                    high = mid - 1;
+                else
+                    return mid; // key found
+            }
+            return -(low + 1);  // key not found
+        }
+
+        private int binarySearch(byte[] searchedKey) {
+            int low = 0;
+            int high = size - 1;
+            final int num_prefixed_fields = 3;
+            int keysOffset = end - (byteWidth * num_prefixed_fields);
+            int keysStart = indirect(bb, keysOffset, byteWidth);
+            int keyByteWidth = readInt(bb, keysOffset + byteWidth, byteWidth);
+
+            while (low <= high) {
+                int mid = (low + high) >>> 1;
+                int keyPos = indirect(bb, keysStart + mid * keyByteWidth, keyByteWidth);
+                int cmp = compareBytes(bb, keyPos, searchedKey);
+                if (cmp < 0)
+                    low = mid + 1;
+                else if (cmp > 0)
+                    high = mid - 1;
+                else
+                    return mid; // key found
+            }
+            return -(low + 1);  // key not found
+        }
+
+        // compares a byte[] against a FBT_KEY
+        private int compareBytes(ReadBuf bb, int start, byte[] other) {
+            int l1 = start;
+            int l2 = 0;
+            byte c1, c2;
+            do {
+                c1 = bb.get(l1);
+                c2 = other[l2];
+                if (c1 == '\0')
+                    return c1 - c2;
+                l1++;
+                l2++;
+                if (l2 == other.length) {
+                    // in our buffer we have an additional \0 byte
+                    // but this does not exist in regular Java strings, so we return now
+                    int cmp = c1 - c2;
+                    if (cmp != 0 || bb.get(l1) == '\0') {
+                        return cmp;
+                    } else {
+                        return 1;
+                    }
+                }
+            }
+            while (c1 == c2);
+            return c1 - c2;
+        }
+
+        // compares a CharSequence against a FBT_KEY
+        private int compareCharSequence(int start, CharSequence other) {
+            int bufferPos = start;
+            int otherPos = 0;
+            int limit = bb.limit();
+            int otherLimit = other.length();
+
+            // special loop for ASCII characters. Most of keys should be ASCII only, so this
+            // loop should be optimized for that.
+            // breaks if a multi-byte character is found
+            while (otherPos < otherLimit) {
+                char c2 = other.charAt(otherPos);
+
+                if (c2 >= 0x80) {
+                    // not a single byte codepoint
+                    break;
+                }
+
+                byte b = bb.get(bufferPos);
+
+                if (b == 0) {
+                    return -c2;
+                } else if (b < 0) {
+                    break;
+                } else if ((char) b != c2) {
+                    return b - c2;
+                }
+                ++bufferPos;
+                ++otherPos;
+            }
+
+            while (bufferPos < limit) {
+
+                int sizeInBuff = Utf8.encodeUtf8CodePoint(other, otherPos, comparisonBuffer);
+
+                if (sizeInBuff == 0) {
+                    // That means we finish with other and there are not more chars to
+                    // compare. String in the buffer is bigger.
+                    return bb.get(bufferPos);
+                }
+
+                for (int i = 0; i < sizeInBuff; i++) {
+                    byte bufferByte = bb.get(bufferPos++);
+                    byte otherByte = comparisonBuffer[i];
+                    if (bufferByte == 0) {
+                        // Our key is finished, so other is bigger
+                        return -otherByte;
+                    } else if (bufferByte != otherByte) {
+                        return bufferByte - otherByte;
+                    }
+                }
+
+                otherPos += sizeInBuff == 4 ? 2 : 1;
+            }
+            return 0;
+        }
+    }
+
+    /**
+     * Object that represents a set of elements in the buffer
+     */
+    public static class Vector extends Sized {
+
+        private static final Vector EMPTY_VECTOR = new Vector(EMPTY_BB, 1, 1);
+
+        Vector(ReadBuf bb, int end, int byteWidth) {
+            super(bb, end, byteWidth);
+        }
+
+        /**
+         * Returns an empty {@link Map}
+         * @return an empty {@link Map}
+         */
+        public static Vector empty() {
+            return EMPTY_VECTOR;
+        }
+
+        /**
+         * Checks if the vector is empty
+         * @return true if vector is empty
+         */
+        public boolean isEmpty() {
+            return this == EMPTY_VECTOR;
+        }
+
+        /**
+         * Appends a text(JSON) representation to a `StringBuilder`
+         */
+        @Override
+        public StringBuilder toString(StringBuilder sb) {
+            sb.append("[ ");
+            int size = size();
+            for (int i = 0; i < size; i++) {
+                get(i).toString(sb);
+                if (i != size - 1) {
+                    sb.append(", ");
+                }
+            }
+            sb.append(" ]");
+            return sb;
+        }
+
+        /**
+         * Get a element in a vector by index
+         *
+         * @param index position of the element
+         * @return {@code Reference} to the element
+         */
+        public Reference get(int index) {
+            long len = size();
+            if (index >= len) {
+                return Reference.NULL_REFERENCE;
+            }
+            int packedType = byteToUnsignedInt(bb.get((int) (end + (len * byteWidth) + index)));
+            int obj_end = end + index * byteWidth;
+            return new Reference(bb, obj_end, byteWidth, packedType);
+        }
+    }
+
+    /**
+     * Object that represents a set of elements with the same type
+     */
+    public static class TypedVector extends Vector {
+
+        private static final TypedVector EMPTY_VECTOR = new TypedVector(EMPTY_BB, 1, 1, FBT_INT);
+
+        private final int elemType;
+
+        TypedVector(ReadBuf bb, int end, int byteWidth, int elemType) {
+            super(bb, end, byteWidth);
+            this.elemType = elemType;
+        }
+
+        public static TypedVector empty() {
+            return EMPTY_VECTOR;
+        }
+
+        /**
+         * Returns whether the vector is empty
+         *
+         * @return true if empty
+         */
+        public boolean isEmptyVector() {
+            return this == EMPTY_VECTOR;
+        }
+
+        /**
+         * Return element type for all elements in the vector
+         *
+         * @return element type
+         */
+        public int getElemType() {
+            return elemType;
+        }
+
+        /**
+         * Get reference to an object in the {@code Vector}
+         *
+         * @param pos position of the object in {@code Vector}
+         * @return reference to element
+         */
+        @Override
+        public Reference get(int pos) {
+            int len = size();
+            if (pos >= len) return Reference.NULL_REFERENCE;
+            int childPos = end + pos * byteWidth;
+            return new Reference(bb, childPos, byteWidth, 1, elemType);
+        }
+    }
+
+    /**
+     * Represent a vector of keys in a map
+     */
+    public static class KeyVector {
+
+        private final TypedVector vec;
+
+        KeyVector(TypedVector vec) {
+            this.vec = vec;
+        }
+
+        /**
+         * Return key
+         *
+         * @param pos position of the key in key vector
+         * @return key
+         */
+        public Key get(int pos) {
+            int len = size();
+            if (pos >= len) return Key.EMPTY;
+            int childPos = vec.end + pos * vec.byteWidth;
+            return new Key(vec.bb, indirect(vec.bb, childPos, vec.byteWidth), 1);
+        }
+
+        /**
+         * Returns size of key vector
+         *
+         * @return size
+         */
+        public int size() {
+            return vec.size();
+        }
+
+        /**
+         * Returns a text(JSON) representation
+         */
+        public String toString() {
+            StringBuilder b = new StringBuilder();
+            b.append('[');
+            for (int i = 0; i < vec.size(); i++) {
+                vec.get(i).toString(b);
+                if (i != vec.size() - 1) {
+                    b.append(", ");
+                }
+            }
+            return b.append("]").toString();
+        }
+    }
+
+    public static class FlexBufferException extends RuntimeException {
+        FlexBufferException(String msg) {
+            super(msg);
+        }
+    }
+
+    static class Unsigned {
+
+        static int byteToUnsignedInt(byte x) {
+            return ((int) x) & 0xff;
+        }
+
+        static int shortToUnsignedInt(short x) {
+            return ((int) x) & 0xffff;
+        }
+
+        static long intToUnsignedLong(int x) {
+            return ((long) x) & 0xffffffffL;
+        }
+    }
+}
+/// @}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java
new file mode 100644
index 00000000..010afccc
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FlexBuffersBuilder.java
@@ -0,0 +1,802 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+
+import static io.objectbox.flatbuffers.FlexBuffers.*;
+import static io.objectbox.flatbuffers.FlexBuffers.Unsigned.byteToUnsignedInt;
+import static io.objectbox.flatbuffers.FlexBuffers.Unsigned.intToUnsignedLong;
+import static io.objectbox.flatbuffers.FlexBuffers.Unsigned.shortToUnsignedInt;
+
+/// @file
+/// @addtogroup flatbuffers_java_api
+/// @{
+
+/**
+ * Helper class that builds FlexBuffers
+ * <p> This class presents all necessary APIs to create FlexBuffers. A `ByteBuffer` will be used to store the
+ * data. It can be created internally, or passed down in the constructor.</p>
+ *
+ * <p>There are some limitations when compared to original implementation in C++. Most notably:
+ * <ul>
+ *   <li><p> No support for mutations (might change in the future).</p></li>
+ *   <li><p> Buffer size limited to {@link Integer#MAX_VALUE}</p></li>
+ *   <li><p> Since Java does not support unsigned type, all unsigned operations accepts an immediate higher representation
+ *   of similar type.</p></li>
+ * </ul>
+ * </p>
+ */
+public class FlexBuffersBuilder {
+
+    /**
+     * No keys or strings will be shared
+     */
+    public static final int BUILDER_FLAG_NONE = 0;
+    /**
+     * Keys will be shared between elements. Identical keys will only be serialized once, thus possibly saving space.
+     * But serialization performance might be slower and consumes more memory.
+     */
+    public static final int BUILDER_FLAG_SHARE_KEYS = 1;
+    /**
+     * Strings will be shared between elements. Identical strings will only be serialized once, thus possibly saving space.
+     * But serialization performance might be slower and consumes more memory. This is ideal if you expect many repeated
+     * strings on the message.
+     */
+    public static final int BUILDER_FLAG_SHARE_STRINGS = 2;
+    /**
+     * Strings and keys will be shared between elements.
+     */
+    public static final int BUILDER_FLAG_SHARE_KEYS_AND_STRINGS = 3;
+    /**
+     * Reserved for the future.
+     */
+    public static final int BUILDER_FLAG_SHARE_KEY_VECTORS = 4;
+    /**
+     * Reserved for the future.
+     */
+    public static final int BUILDER_FLAG_SHARE_ALL = 7;
+
+    /// @cond FLATBUFFERS_INTERNAL
+    private static final int WIDTH_8 = 0;
+    private static final int WIDTH_16 = 1;
+    private static final int WIDTH_32 = 2;
+    private static final int WIDTH_64 = 3;
+    private final ReadWriteBuf bb;
+    private final ArrayList<Value> stack = new ArrayList<>();
+    private final HashMap<String, Integer> keyPool = new HashMap<>();
+    private final HashMap<String, Integer> stringPool = new HashMap<>();
+    private final int flags;
+    private boolean finished = false;
+
+    // A lambda to sort map keys
+    private Comparator<Value> keyComparator = new Comparator<Value>() {
+        @Override
+        public int compare(Value o1, Value o2) {
+            int ia = o1.key;
+            int io =  o2.key;
+            byte c1, c2;
+            do {
+                c1 = bb.get(ia);
+                c2 = bb.get(io);
+                if (c1 == 0)
+                    return c1 - c2;
+                ia++;
+                io++;
+            }
+            while (c1 == c2);
+            return c1 - c2;
+        }
+    };
+    /// @endcond
+
+    /**
+     * Constructs a newly allocated {@code FlexBuffersBuilder} with {@link #BUILDER_FLAG_SHARE_KEYS} set.
+     * @param bufSize size of buffer in bytes.
+     */
+    public FlexBuffersBuilder(int bufSize) {
+        this(new ArrayReadWriteBuf(bufSize), BUILDER_FLAG_SHARE_KEYS);
+    }
+
+    /**
+     * Constructs a newly allocated {@code FlexBuffersBuilder} with {@link #BUILDER_FLAG_SHARE_KEYS} set.
+     */
+    public FlexBuffersBuilder() {
+        this(256);
+    }
+
+    /**
+     * Constructs a newly allocated {@code FlexBuffersBuilder}.
+     *
+     * @param bb    `ByteBuffer` that will hold the message
+     * @param flags Share flags
+     */
+    @Deprecated
+    public FlexBuffersBuilder(ByteBuffer bb, int flags) {
+        this(new ArrayReadWriteBuf(bb.array()), flags);
+    }
+
+    public FlexBuffersBuilder(ReadWriteBuf bb, int flags) {
+        this.bb = bb;
+        this.flags = flags;
+    }
+
+    /**
+     * Constructs a newly allocated {@code FlexBuffersBuilder}.
+     * By default same keys will be serialized only once
+     * @param bb `ByteBuffer` that will hold the message
+     */
+    public FlexBuffersBuilder(ByteBuffer bb) {
+        this(bb, BUILDER_FLAG_SHARE_KEYS);
+    }
+
+    /**
+     * Reset the FlexBuffersBuilder by purging all data that it holds.
+     */
+    public void clear(){
+        bb.clear();
+        stack.clear();
+        keyPool.clear();
+        stringPool.clear();
+        finished = false;
+    }
+
+    /**
+     * Return `ByteBuffer` containing FlexBuffer message. {@code #finish()} must be called before calling this
+     * function otherwise an assert will trigger.
+     *
+     * @return `ByteBuffer` with finished message
+     */
+    public ReadWriteBuf getBuffer() {
+        assert (finished);
+        return bb;
+    }
+
+    /**
+     * Insert a null value into the buffer
+     */
+    public void putNull() {
+        putNull(null);
+    }
+
+    /**
+     * Insert a null value into the buffer
+     * @param key key used to store element in map
+     */
+    public void putNull(String key) {
+        stack.add(Value.nullValue(putKey(key)));
+    }
+
+    /**
+     * Insert a single boolean into the buffer
+     * @param val true or false
+     */
+    public void putBoolean(boolean val) {
+        putBoolean(null, val);
+    }
+
+    /**
+     * Insert a single boolean into the buffer
+     * @param key key used to store element in map
+     * @param val true or false
+     */
+    public void putBoolean(String key, boolean val) {
+        stack.add(Value.bool(putKey(key), val));
+    }
+
+    private int putKey(String key) {
+        if (key == null) {
+            return -1;
+        }
+        int pos = bb.writePosition();
+        if ((flags & BUILDER_FLAG_SHARE_KEYS) != 0) {
+            Integer keyFromPool = keyPool.get(key);
+            if (keyFromPool == null) {
+                byte[]  keyBytes = key.getBytes(StandardCharsets.UTF_8);
+                bb.put(keyBytes, 0, keyBytes.length);
+                bb.put((byte) 0);
+                keyPool.put(key, pos);
+            } else {
+                pos = keyFromPool;
+            }
+        } else {
+            byte[]  keyBytes = key.getBytes(StandardCharsets.UTF_8);
+            bb.put(keyBytes, 0, keyBytes.length);
+            bb.put((byte) 0);
+            keyPool.put(key, pos);
+        }
+        return pos;
+    }
+
+    /**
+     * Adds a integer into the buff
+     * @param val integer
+     */
+    public void putInt(int val) {
+        putInt(null, val);
+    }
+
+    /**
+     * Adds a integer into the buff
+     * @param key key used to store element in map
+     * @param val integer
+     */
+    public void putInt(String key, int val) {
+        putInt(key, (long) val);
+    }
+
+    /**
+     * Adds a integer into the buff
+     * @param key key used to store element in map
+     * @param val 64-bit integer
+     */
+    public void putInt(String key, long val) {
+        int iKey = putKey(key);
+        if (Byte.MIN_VALUE <= val && val <= Byte.MAX_VALUE) {
+            stack.add(Value.int8(iKey, (int) val));
+        } else if (Short.MIN_VALUE <= val && val <= Short.MAX_VALUE) {
+            stack.add(Value.int16(iKey, (int) val));
+        } else if (Integer.MIN_VALUE <= val && val <= Integer.MAX_VALUE) {
+            stack.add(Value.int32(iKey, (int) val));
+        } else {
+            stack.add(Value.int64(iKey, val));
+        }
+    }
+
+    /**
+     * Adds a 64-bit integer into the buff
+     * @param value integer
+     */
+    public void putInt(long value) {
+        putInt(null, value);
+    }
+
+    /**
+     * Adds a unsigned integer into the buff.
+     * @param value integer representing unsigned value
+     */
+    public void putUInt(int value) {
+        putUInt(null, (long) value);
+    }
+
+    /**
+     * Adds a unsigned integer (stored in a signed 64-bit integer) into the buff.
+     * @param value integer representing unsigned value
+     */
+    public void putUInt(long value) {
+        putUInt(null, value);
+    }
+
+    /**
+     * Adds a 64-bit unsigned integer (stored as {@link BigInteger}) into the buff.
+     * Warning: This operation might be very slow.
+     * @param value integer representing unsigned value
+     */
+    public void putUInt64(BigInteger value) {
+        putUInt64(null, value.longValue());
+    }
+
+    private void putUInt64(String key, long value) {
+        stack.add(Value.uInt64(putKey(key), value));
+    }
+
+    private void putUInt(String key, long value) {
+        int iKey = putKey(key);
+        Value vVal;
+
+        int width = widthUInBits(value);
+
+        if (width == WIDTH_8) {
+            vVal = Value.uInt8(iKey, (int)value);
+        } else if (width == WIDTH_16) {
+            vVal = Value.uInt16(iKey, (int)value);
+        } else if (width == WIDTH_32) {
+            vVal = Value.uInt32(iKey, (int)value);
+        } else {
+            vVal = Value.uInt64(iKey, value);
+        }
+        stack.add(vVal);
+    }
+
+    /**
+     * Adds a 32-bit float into the buff.
+     * @param value float representing value
+     */
+    public void putFloat(float value) {
+        putFloat(null, value);
+    }
+
+    /**
+     * Adds a 32-bit float into the buff.
+     * @param key key used to store element in map
+     * @param value float representing value
+     */
+    public void putFloat(String key, float val) {
+        stack.add(Value.float32(putKey(key), val));
+    }
+
+    /**
+     * Adds a 64-bit float into the buff.
+     * @param value float representing value
+     */
+    public void putFloat(double value) {
+        putFloat(null, value);
+    }
+
+    /**
+     * Adds a 64-bit float into the buff.
+     * @param key key used to store element in map
+     * @param value float representing value
+     */
+    public void putFloat(String key, double val) {
+        stack.add(Value.float64(putKey(key), val));
+    }
+
+    /**
+     * Adds a String into the buffer
+     * @param value string
+     * @return start position of string in the buffer
+     */
+    public int putString(String value) {
+        return putString(null, value);
+    }
+
+    /**
+     * Adds a String into the buffer
+     * @param key key used to store element in map
+     * @param value string
+     * @return start position of string in the buffer
+     */
+    public int putString(String key, String val) {
+        int iKey = putKey(key);
+        if ((flags & FlexBuffersBuilder.BUILDER_FLAG_SHARE_STRINGS) != 0) {
+            Integer i = stringPool.get(val);
+            if (i == null) {
+                Value value = writeString(iKey, val);
+                stringPool.put(val, (int) value.iValue);
+                stack.add(value);
+                return (int) value.iValue;
+            } else {
+                int bitWidth = widthUInBits(val.length());
+                stack.add(Value.blob(iKey, i, FBT_STRING, bitWidth));
+                return i;
+            }
+        } else {
+            Value value = writeString(iKey, val);
+            stack.add(value);
+            return (int) value.iValue;
+        }
+    }
+
+    private Value writeString(int key, String s) {
+        return writeBlob(key, s.getBytes(StandardCharsets.UTF_8), FBT_STRING, true);
+    }
+
+    // in bits to fit a unsigned int
+    static int widthUInBits(long len) {
+        if (len <= byteToUnsignedInt((byte)0xff)) return WIDTH_8;
+        if (len <= shortToUnsignedInt((short)0xffff)) return WIDTH_16;
+        if (len <= intToUnsignedLong(0xffff_ffff)) return WIDTH_32;
+        return WIDTH_64;
+    }
+
+    private Value writeBlob(int key, byte[] blob, int type, boolean trailing) {
+        int bitWidth = widthUInBits(blob.length);
+        int byteWidth = align(bitWidth);
+        writeInt(blob.length, byteWidth);
+        int sloc = bb.writePosition();
+        bb.put(blob, 0, blob.length);
+        if (trailing) {
+            bb.put((byte) 0);
+        }
+        return Value.blob(key, sloc, type, bitWidth);
+    }
+
+    // Align to prepare for writing a scalar with a certain size.
+    private int align(int alignment) {
+        int byteWidth = 1 << alignment;
+        int padBytes = Value.paddingBytes(bb.writePosition(), byteWidth);
+        while (padBytes-- != 0) {
+            bb.put((byte) 0);
+        }
+        return byteWidth;
+    }
+
+    private void writeInt(long value, int byteWidth) {
+        switch (byteWidth) {
+            case 1: bb.put((byte) value); break;
+            case 2: bb.putShort((short) value); break;
+            case 4: bb.putInt((int) value); break;
+            case 8: bb.putLong(value); break;
+        }
+    }
+
+    /**
+     * Adds a byte array into the message
+     * @param value byte array
+     * @return position in buffer as the start of byte array
+     */
+    public int putBlob(byte[] value) {
+        return putBlob(null, value);
+    }
+
+    /**
+     * Adds a byte array into the message
+     * @param key key used to store element in map
+     * @param value byte array
+     * @return position in buffer as the start of byte array
+     */
+    public int putBlob(String key, byte[] val) {
+        int iKey = putKey(key);
+        Value value = writeBlob(iKey, val, FBT_BLOB, false);
+        stack.add(value);
+        return (int) value.iValue;
+    }
+
+    /**
+     * Start a new vector in the buffer.
+     * @return a reference indicating position of the vector in buffer. This
+     * reference must be passed along when the vector is finished using endVector()
+     */
+    public int startVector() {
+        return stack.size();
+    }
+
+    /**
+     * Finishes a vector, but writing the information in the buffer
+     * @param key   key used to store element in map
+     * @param start reference for beginning of the vector. Returned by {@link startVector()}
+     * @param typed boolean indicating whether vector is typed
+     * @param fixed boolean indicating whether vector is fixed
+     * @return      Reference to the vector
+     */
+    public int endVector(String key, int start, boolean typed, boolean fixed) {
+        int iKey = putKey(key);
+        Value vec = createVector(iKey, start, stack.size() - start, typed, fixed, null);
+        // Remove temp elements and return vector.
+        while (stack.size() > start) {
+            stack.remove(stack.size() - 1);
+        }
+        stack.add(vec);
+        return (int) vec.iValue;
+    }
+
+    /**
+     * Finish writing the message into the buffer. After that no other element must
+     * be inserted into the buffer. Also, you must call this function before start using the
+     * FlexBuffer message
+     * @return `ByteBuffer` containing the FlexBuffer message
+     */
+    public ByteBuffer finish() {
+        // If you hit this assert, you likely have objects that were never included
+        // in a parent. You need to have exactly one root to finish a buffer.
+        // Check your Start/End calls are matched, and all objects are inside
+        // some other object.
+        assert (stack.size() == 1);
+        // Write root value.
+        int byteWidth = align(stack.get(0).elemWidth(bb.writePosition(), 0));
+        writeAny(stack.get(0), byteWidth);
+        // Write root type.
+        bb.put(stack.get(0).storedPackedType());
+        // Write root size. Normally determined by parent, but root has no parent :)
+        bb.put((byte) byteWidth);
+        this.finished = true;
+        return ByteBuffer.wrap(bb.data(), 0, bb.writePosition());
+    }
+
+    /*
+     * Create a vector based on the elements stored in the stack
+     *
+     * @param key    reference to its key
+     * @param start  element in the stack
+     * @param length size of the vector
+     * @param typed  whether is TypedVector or not
+     * @param fixed  whether is Fixed vector or not
+     * @param keys   Value representing key vector
+     * @return Value representing the created vector
+     */
+    private Value createVector(int key, int start, int length, boolean typed, boolean fixed, Value keys) {
+        if (fixed & !typed)
+            throw new UnsupportedOperationException("Untyped fixed vector is not supported");
+
+        // Figure out smallest bit width we can store this vector with.
+        int bitWidth = Math.max(WIDTH_8, widthUInBits(length));
+        int prefixElems = 1;
+        if (keys != null) {
+            // If this vector is part of a map, we will pre-fix an offset to the keys
+            // to this vector.
+            bitWidth = Math.max(bitWidth, keys.elemWidth(bb.writePosition(), 0));
+            prefixElems += 2;
+        }
+        int vectorType = FBT_KEY;
+        // Check bit widths and types for all elements.
+        for (int i = start; i < stack.size(); i++) {
+            int elemWidth = stack.get(i).elemWidth(bb.writePosition(), i + prefixElems);
+            bitWidth = Math.max(bitWidth, elemWidth);
+            if (typed) {
+                if (i == start) {
+                    vectorType = stack.get(i).type;
+                    if (!FlexBuffers.isTypedVectorElementType(vectorType)) {
+                        throw new FlexBufferException("TypedVector does not support this element type");
+                    }
+                } else {
+                    // If you get this assert, you are writing a typed vector with
+                    // elements that are not all the same type.
+                    assert (vectorType == stack.get(i).type);
+                }
+            }
+        }
+        // If you get this assert, your fixed types are not one of:
+        // Int / UInt / Float / Key.
+        assert (!fixed || FlexBuffers.isTypedVectorElementType(vectorType));
+
+        int byteWidth = align(bitWidth);
+        // Write vector. First the keys width/offset if available, and size.
+        if (keys != null) {
+            writeOffset(keys.iValue, byteWidth);
+            writeInt(1L << keys.minBitWidth, byteWidth);
+        }
+        if (!fixed) {
+            writeInt(length, byteWidth);
+        }
+        // Then the actual data.
+        int vloc = bb.writePosition();
+        for (int i = start; i < stack.size(); i++) {
+            writeAny(stack.get(i), byteWidth);
+        }
+        // Then the types.
+        if (!typed) {
+            for (int i = start; i < stack.size(); i++) {
+                bb.put(stack.get(i).storedPackedType(bitWidth));
+            }
+        }
+        return new Value(key, keys != null ? FBT_MAP
+                : (typed ? FlexBuffers.toTypedVector(vectorType, fixed ? length : 0)
+                : FBT_VECTOR), bitWidth, vloc);
+    }
+
+    private void writeOffset(long val, int byteWidth) {
+        int reloff = (int) (bb.writePosition() - val);
+        assert (byteWidth == 8 || reloff < 1L << (byteWidth * 8));
+        writeInt(reloff, byteWidth);
+    }
+
+    private void writeAny(final Value val, int byteWidth) {
+        switch (val.type) {
+            case FBT_NULL:
+            case FBT_BOOL:
+            case FBT_INT:
+            case FBT_UINT:
+                writeInt(val.iValue, byteWidth);
+                break;
+            case FBT_FLOAT:
+                writeDouble(val.dValue, byteWidth);
+                break;
+            default:
+                writeOffset(val.iValue, byteWidth);
+                break;
+        }
+    }
+
+    private void writeDouble(double val, int byteWidth) {
+        if (byteWidth == 4) {
+            bb.putFloat((float) val);
+        } else if (byteWidth == 8) {
+            bb.putDouble(val);
+        }
+    }
+
+    /**
+     * Start a new map in the buffer.
+     * @return a reference indicating position of the map in buffer. This
+     * reference must be passed along when the map is finished using endMap()
+     */
+    public int startMap() {
+        return stack.size();
+    }
+
+    /**
+     * Finishes a map, but writing the information in the buffer
+     * @param key   key used to store element in map
+     * @param start reference for beginning of the map. Returned by {@link startMap()}
+     * @return      Reference to the map
+     */
+    public int endMap(String key, int start) {
+        int iKey = putKey(key);
+
+        Collections.sort(stack.subList(start, stack.size()), keyComparator);
+
+        Value keys = createKeyVector(start, stack.size() - start);
+        Value vec = createVector(iKey, start, stack.size() - start, false, false, keys);
+        // Remove temp elements and return map.
+        while (stack.size() > start) {
+            stack.remove(stack.size() - 1);
+        }
+        stack.add(vec);
+        return (int) vec.iValue;
+    }
+
+    private Value createKeyVector(int start, int length) {
+        // Figure out smallest bit width we can store this vector with.
+        int bitWidth = Math.max(WIDTH_8, widthUInBits(length));
+        int prefixElems = 1;
+        // Check bit widths and types for all elements.
+        for (int i = start; i < stack.size(); i++) {
+            int elemWidth = Value.elemWidth(FBT_KEY, WIDTH_8, stack.get(i).key, bb.writePosition(), i + prefixElems);
+            bitWidth = Math.max(bitWidth, elemWidth);
+        }
+
+        int byteWidth = align(bitWidth);
+        // Write vector. First the keys width/offset if available, and size.
+        writeInt(length, byteWidth);
+        // Then the actual data.
+        int vloc = bb.writePosition();
+        for (int i = start; i < stack.size(); i++) {
+            int pos = stack.get(i).key;
+            assert(pos != -1);
+            writeOffset(stack.get(i).key, byteWidth);
+        }
+        // Then the types.
+        return new Value(-1, FlexBuffers.toTypedVector(FBT_KEY,0), bitWidth, vloc);
+    }
+
+    private static class Value {
+        final int type;
+        // for scalars, represents scalar size in bytes
+        // for vectors, represents the size
+        // for string, length
+        final int minBitWidth;
+        // float value
+        final double dValue;
+        // integer value
+        long iValue;
+        // position of the key associated with this value in buffer
+        int key;
+
+        Value(int key, int type, int bitWidth, long iValue) {
+            this.key = key;
+            this.type = type;
+            this.minBitWidth = bitWidth;
+            this.iValue = iValue;
+            this.dValue = Double.MIN_VALUE;
+        }
+
+        Value(int key, int type, int bitWidth, double dValue) {
+            this.key = key;
+            this.type = type;
+            this.minBitWidth = bitWidth;
+            this.dValue = dValue;
+            this.iValue = Long.MIN_VALUE;
+        }
+
+        static Value nullValue(int key) {
+            return new Value(key, FBT_NULL, WIDTH_8, 0);
+        }
+
+        static Value bool(int key, boolean b) {
+            return new Value(key, FBT_BOOL, WIDTH_8, b ? 1 : 0);
+        }
+
+        static Value blob(int key, int position, int type, int bitWidth) {
+            return new Value(key, type, bitWidth, position);
+        }
+
+        static Value int8(int key, int value) {
+            return new Value(key, FBT_INT, WIDTH_8, value);
+        }
+
+        static Value int16(int key, int value) {
+            return new Value(key, FBT_INT, WIDTH_16, value);
+        }
+
+        static Value int32(int key, int value) {
+            return new Value(key, FBT_INT, WIDTH_32, value);
+        }
+
+        static Value int64(int key, long value) {
+            return new Value(key, FBT_INT, WIDTH_64, value);
+        }
+
+        static Value uInt8(int key, int value) {
+            return new Value(key, FBT_UINT, WIDTH_8, value);
+        }
+
+        static Value uInt16(int key, int value) {
+            return new Value(key, FBT_UINT, WIDTH_16, value);
+        }
+
+        static Value uInt32(int key, int value) {
+            return new Value(key, FBT_UINT, WIDTH_32, value);
+        }
+
+        static Value uInt64(int key, long value) {
+            return new Value(key, FBT_UINT, WIDTH_64, value);
+        }
+
+        static Value float32(int key, float value) {
+            return new Value(key, FBT_FLOAT, WIDTH_32, value);
+        }
+
+        static Value float64(int key, double value) {
+            return new Value(key, FBT_FLOAT, WIDTH_64, value);
+        }
+
+        private byte storedPackedType() {
+            return storedPackedType(WIDTH_8);
+        }
+
+        private byte storedPackedType(int parentBitWidth) {
+            return packedType(storedWidth(parentBitWidth), type);
+        }
+
+        private static byte packedType(int bitWidth, int type) {
+            return (byte) (bitWidth | (type << 2));
+        }
+
+        private int storedWidth(int parentBitWidth) {
+            if (FlexBuffers.isTypeInline(type)) {
+                return Math.max(minBitWidth, parentBitWidth);
+            } else {
+                return minBitWidth;
+            }
+        }
+
+        private int elemWidth(int bufSize, int elemIndex) {
+            return elemWidth(type, minBitWidth, iValue, bufSize, elemIndex);
+        }
+
+        private static int elemWidth(int type, int minBitWidth, long iValue, int bufSize, int elemIndex) {
+            if (FlexBuffers.isTypeInline(type)) {
+                return minBitWidth;
+            } else {
+                // We have an absolute offset, but want to store a relative offset
+                // elem_index elements beyond the current buffer end. Since whether
+                // the relative offset fits in a certain byte_width depends on
+                // the size of the elements before it (and their alignment), we have
+                // to test for each size in turn.
+
+                // Original implementation checks for largest scalar
+                // which is long unsigned int
+                for (int byteWidth = 1; byteWidth <= 32; byteWidth *= 2) {
+                    // Where are we going to write this offset?
+                    int offsetLoc = bufSize + paddingBytes(bufSize, byteWidth) + (elemIndex * byteWidth);
+                    // Compute relative offset.
+                    long offset = offsetLoc - iValue;
+                    // Does it fit?
+                    int bitWidth = widthUInBits(offset);
+                    if (((1L) << bitWidth) == byteWidth)
+                        return bitWidth;
+                }
+                assert (false);  // Must match one of the sizes above.
+                return WIDTH_64;
+            }
+        }
+
+        private static int paddingBytes(int bufSize, int scalarSize) {
+            return ((~bufSize) + 1) & (scalarSize - 1);
+        }
+    }
+}
+
+/// @}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/FloatVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FloatVector.java
new file mode 100644
index 00000000..845a6f09
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/FloatVector.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of float values.
+ */
+public final class FloatVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public FloatVector __assign(int _vector, ByteBuffer _bb) {
+    __reset(_vector, Constants.SIZEOF_FLOAT, _bb); return this;
+  }
+
+  /**
+   * Reads the float value at the given index.
+   *
+   * @param j The index from which the float value will be read.
+   * @return the float value at the given index.
+   */
+  public float get(int j) { 
+    return bb.getFloat(__element(j));
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/IntVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/IntVector.java
new file mode 100644
index 00000000..4619b90b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/IntVector.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of signed or unsigned 32-bit values.
+ */
+public final class IntVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public IntVector __assign(int _vector, ByteBuffer _bb) {
+    __reset(_vector, Constants.SIZEOF_INT, _bb); return this;
+  }
+
+  /**
+   * Reads the integer at the given index.
+   *
+   * @param j The index from which the integer will be read.
+   * @return the 32-bit value at the given index.
+   */
+  public int get(int j) {
+    return bb.getInt(__element(j));
+  }
+
+  /**
+   * Reads the integer at the given index, zero-extends it to type long, and returns the result,
+   * which is therefore in the range 0 through 4294967295.
+   *
+   * @param j The index from which the integer will be read.
+   * @return the unsigned 32-bit at the given index.
+   */
+  public long getAsUnsigned(int j) {
+    return (long) get(j) & 0xFFFFFFFFL;
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/LICENSE.txt b/objectbox-java/src/main/java/io/objectbox/flatbuffers/LICENSE.txt
new file mode 100644
index 00000000..d6456956
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/LICENSE.txt
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/LongVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/LongVector.java
new file mode 100644
index 00000000..f3ccfc9a
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/LongVector.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of long values.
+ */
+public final class LongVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public LongVector __assign(int _vector, ByteBuffer _bb) {
+    __reset(_vector, Constants.SIZEOF_LONG, _bb); return this;
+  }
+
+  /**
+   * Reads the long value at the given index.
+   *
+   * @param j The index from which the long value will be read.
+   * @return the signed 64-bit value at the given index.
+   */
+  public long get(int j) {
+    return bb.getLong(__element(j));
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md b/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md
new file mode 100644
index 00000000..90455638
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/README.md
@@ -0,0 +1,15 @@
+# FlatBuffers
+                         
+This is a copy of the [FlatBuffers](https://github.com/google/flatbuffers) for Java source code in a custom package
+to avoid conflicts with FlatBuffers generated Java code from users of this library.
+
+Current version: `23.5.26` (Note: version in `Constants.java` may be lower).
+
+Copy a different version using the script in `scripts\update-flatbuffers.sh`.
+It expects FlatBuffers source files in the `../flatbuffers` directory (e.g. check out
+the desired FlatBuffers tag from https://github.com/objectbox/flatbuffers next to this repo).
+The Java library is expected in `objectbox-java`, e.g. run the script from the root of this repo.
+
+## Licensing
+
+Flatbuffers is licensed under the Apache License, Version 2.0.
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ReadBuf.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ReadBuf.java
new file mode 100644
index 00000000..17a8ba10
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ReadBuf.java
@@ -0,0 +1,81 @@
+package io.objectbox.flatbuffers;
+
+/**
+ *  Represent a chunk of data, where FlexBuffers will read from.
+ */
+public interface ReadBuf {
+
+  /**
+   * Read boolean from data. Booleans as stored as single byte
+   * @param index position of the element in ReadBuf
+   * @return boolean element
+   */
+  boolean getBoolean(int index);
+
+  /**
+   * Read a byte from data.
+   * @param index position of the element in ReadBuf
+   * @return a byte
+   */
+  byte get(int index);
+
+  /**
+   * Read a short from data.
+   * @param index position of the element in ReadBuf
+   * @return a short
+   */
+  short getShort(int index);
+
+  /**
+   * Read a 32-bit int from data.
+   * @param index position of the element in ReadBuf
+   * @return an int
+   */
+  int getInt(int index);
+
+  /**
+   * Read a 64-bit long from data.
+   * @param index position of the element in ReadBuf
+   * @return a long
+   */
+  long getLong(int index);
+
+  /**
+   * Read a 32-bit float from data.
+   * @param index position of the element in ReadBuf
+   * @return a float
+   */
+  float getFloat(int index);
+
+  /**
+   * Read a 64-bit float from data.
+   * @param index position of the element in ReadBuf
+   * @return a double
+   */
+  double getDouble(int index);
+
+  /**
+   * Read an UTF-8 string from data.
+   * @param start initial element of the string
+   * @param size size of the string in bytes.
+   * @return a {@code String}
+   */
+  String getString(int start, int size);
+
+  /**
+   * Expose ReadBuf as an array of bytes.
+   * This method is meant to be as efficient as possible, so for a array-backed ReadBuf, it should
+   * return its own internal data. In case access to internal data is not possible,
+   * a copy of the data into an array of bytes might occur.
+   * @return ReadBuf as an array of bytes
+   */
+  byte[] data();
+
+  /**
+   * Defines the size of the message in the buffer. It also determines last position that buffer
+   * can be read. Last byte to be accessed is in position {@code limit() -1}.
+   * @return indicate last position
+   */
+  int limit();
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ReadWriteBuf.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ReadWriteBuf.java
new file mode 100644
index 00000000..91cc6f88
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ReadWriteBuf.java
@@ -0,0 +1,142 @@
+package io.objectbox.flatbuffers;
+
+/**
+ * Interface to represent a read-write buffer. This interface will be used to access and write
+ * FlexBuffers message.
+ */
+public interface ReadWriteBuf extends ReadBuf {
+
+    /**
+     * Clears (resets) the buffer so that it can be reused. Write position will be set to the
+     * start.
+     */
+    void clear();
+
+    /**
+     * Put a boolean into the buffer at {@code writePosition()} . Booleans as stored as single
+     * byte. Write position will be incremented.
+     * @return boolean element
+     */
+    void putBoolean(boolean value);
+
+    /**
+     * Put an array of bytes into the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     * @param value the data to be copied
+     * @param start initial position on value to be copied
+     * @param length amount of bytes to be copied
+     */
+    void put (byte[] value, int start, int length);
+
+    /**
+     * Write a byte into the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     */
+    void put(byte value);
+
+    /**
+     * Write a 16-bit into in the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     */
+    void putShort(short value);
+
+    /**
+     * Write a 32-bit into in the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     */
+    void putInt(int value);
+
+    /**
+     * Write a 64-bit into in the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     */
+    void putLong(long value);
+
+    /**
+     * Write a 32-bit float into the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     */
+    void putFloat(float value);
+
+    /**
+     * Write a 64-bit float into the buffer at {@code writePosition()}. Write position will be
+     * incremented.
+     */
+    void putDouble(double value);
+
+    /**
+     * Write boolean into a given position on the buffer. Booleans as stored as single byte.
+     * @param index position of the element in buffer
+     */
+    void setBoolean(int index, boolean value);
+
+    /**
+     * Read a byte from data.
+     * @param index position of the element in the buffer
+     * @return a byte
+     */
+    void set(int index, byte value);
+
+    /**
+     * Write an array of bytes into the buffer.
+     * @param index initial position of the buffer to be written
+     * @param value the data to be copied
+     * @param start initial position on value to be copied
+     * @param length amount of bytes to be copied
+     */
+    void set(int index, byte[] value, int start, int length);
+
+    /**
+     * Read a short from data.
+     * @param index position of the element in ReadBuf
+     * @return a short
+     */
+    void setShort(int index, short value);
+
+    /**
+     * Read a 32-bit int from data.
+     * @param index position of the element in ReadBuf
+     * @return an int
+     */
+    void setInt(int index, int value);
+
+    /**
+     * Read a 64-bit long from data.
+     * @param index position of the element in ReadBuf
+     * @return a long
+     */
+    void setLong(int index, long value);
+
+    /**
+     * Read a 32-bit float from data.
+     * @param index position of the element in ReadBuf
+     * @return a float
+     */
+    void setFloat(int index, float value);
+
+    /**
+     * Read a 64-bit float from data.
+     * @param index position of the element in ReadBuf
+     * @return a double
+     */
+    void setDouble(int index, double value);
+
+
+    int writePosition();
+    /**
+     * Defines the size of the message in the buffer. It also determines last position that buffer
+     * can be read or write. Last byte to be accessed is in position {@code limit() -1}.
+     * @return indicate last position
+     */
+    int limit();
+
+    /**
+     * Request capacity of the buffer. In case buffer is already larger
+     * than the requested, this method will just return true. Otherwise
+     * It might try to resize the buffer.
+     *
+     * @return true if buffer is able to offer
+     * the requested capacity
+     */
+    boolean requestCapacity(int capacity);
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/ShortVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ShortVector.java
new file mode 100644
index 00000000..2a221613
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/ShortVector.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of signed or unsigned 16-bit values.
+ */
+public final class ShortVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public ShortVector __assign(int _vector, ByteBuffer _bb) {
+    __reset(_vector, Constants.SIZEOF_SHORT, _bb); return this;
+  }
+
+  /**
+   * Reads the short value at the given index.
+   *
+   * @param j The index from which the short value will be read.
+   * @return the 16-bit value at the given index.
+   */
+  public short get(int j) {
+    return bb.getShort(__element(j));
+  }
+
+  /**
+   * Reads the short at the given index, zero-extends it to type int, and returns the result,
+   * which is therefore in the range 0 through 65535.
+   *
+   * @param j The index from which the short value will be read.
+   * @return the unsigned 16-bit at the given index.
+   */
+  public int getAsUnsigned(int j) {
+    return (int) get(j) & 0xFFFF;
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/StringVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/StringVector.java
new file mode 100644
index 00000000..16e4730b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/StringVector.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of String.
+ */
+public final class StringVector extends BaseVector {
+  private Utf8 utf8 = Utf8.getDefault();
+
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _element_size Size of a vector element.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public StringVector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+    __reset(_vector, _element_size, _bb); return this;
+  }
+
+  /**
+   * Reads the String at the given index.
+   *
+   * @param j The index from which the String value will be read.
+   * @return the String at the given index.
+   */
+  public String get(int j) {
+    return Table.__string(__element(j), bb, utf8);
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Struct.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Struct.java
new file mode 100644
index 00000000..d5ffd52a
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Struct.java
@@ -0,0 +1,61 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import java.nio.ByteBuffer;
+
+/// @cond FLATBUFFERS_INTERNAL
+
+/**
+ * All structs in the generated code derive from this class, and add their own accessors.
+ */
+public class Struct {
+  /** Used to hold the position of the `bb` buffer. */
+  protected int bb_pos;
+  /** The underlying ByteBuffer to hold the data of the Struct. */
+  protected ByteBuffer bb;
+
+  /**
+   * Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within.
+   *
+   * This method exists primarily to allow recycling Table instances without risking memory leaks
+   * due to {@code ByteBuffer} references.
+   */
+  protected void __reset(int _i, ByteBuffer _bb) { 
+    bb = _bb;
+    if (bb != null) {
+      bb_pos = _i;
+    } else {
+      bb_pos = 0;
+    }
+  }
+
+  /**
+   * Resets internal state with a null {@code ByteBuffer} and a zero position.
+   *
+   * This method exists primarily to allow recycling Struct instances without risking memory leaks
+   * due to {@code ByteBuffer} references. The instance will be unusable until it is assigned
+   * again to a {@code ByteBuffer}.
+   *
+   * @param struct the instance to reset to initial state
+   */
+  public void __reset() {
+    __reset(0, null);
+  }
+}
+
+/// @endcond
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Table.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Table.java
new file mode 100644
index 00000000..a828abc2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Table.java
@@ -0,0 +1,322 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/// @cond FLATBUFFERS_INTERNAL
+
+/**
+ * All tables in the generated code derive from this class, and add their own accessors.
+ */
+public class Table {
+  /** Used to hold the position of the `bb` buffer. */
+  protected int bb_pos;
+  /** The underlying ByteBuffer to hold the data of the Table. */
+  protected ByteBuffer bb;
+  /** Used to hold the vtable position. */
+  private int vtable_start;
+  /** Used to hold the vtable size. */
+  private int vtable_size;
+  Utf8 utf8 = Utf8.getDefault();
+
+  /**
+   * Get the underlying ByteBuffer.
+   *
+   * @return Returns the Table's ByteBuffer.
+   */
+  public ByteBuffer getByteBuffer() { return bb; }
+
+  /**
+   * Look up a field in the vtable.
+   *
+   * @param vtable_offset An `int` offset to the vtable in the Table's ByteBuffer.
+   * @return Returns an offset into the object, or `0` if the field is not present.
+   */
+  protected int __offset(int vtable_offset) {
+    return vtable_offset < vtable_size ? bb.getShort(vtable_start + vtable_offset) : 0;
+  }
+
+  protected static int __offset(int vtable_offset, int offset, ByteBuffer bb) {
+    int vtable = bb.capacity() - offset;
+    return bb.getShort(vtable + vtable_offset - bb.getInt(vtable)) + vtable;
+  }
+
+  /**
+   * Retrieve a relative offset.
+   *
+   * @param offset An `int` index into the Table's ByteBuffer containing the relative offset.
+   * @return Returns the relative offset stored at `offset`.
+   */
+  protected int __indirect(int offset) {
+    return offset + bb.getInt(offset);
+  }
+
+  /**
+   * Retrieve a relative offset.
+   *
+   * @param offset An `int` index into a ByteBuffer containing the relative offset.
+   * @param bb from which the relative offset will be retrieved.
+   * @return Returns the relative offset stored at `offset`.
+   */
+  protected static int __indirect(int offset, ByteBuffer bb) {
+    return offset + bb.getInt(offset);
+  }
+
+  /**
+   * Create a Java `String` from UTF-8 data stored inside the FlatBuffer.
+   *
+   * This allocates a new string and converts to wide chars upon each access,
+   * which is not very efficient. Instead, each FlatBuffer string also comes with an
+   * accessor based on __vector_as_bytebuffer below, which is much more efficient,
+   * assuming your Java program can handle UTF-8 data directly.
+   *
+   * @param offset An `int` index into the Table's ByteBuffer.
+   * @return Returns a `String` from the data stored inside the FlatBuffer at `offset`.
+   */
+  protected String __string(int offset) {
+    return __string(offset, bb, utf8);
+  }
+
+  /**
+   * Create a Java `String` from UTF-8 data stored inside the FlatBuffer.
+   *
+   * This allocates a new string and converts to wide chars upon each access,
+   * which is not very efficient. Instead, each FlatBuffer string also comes with an
+   * accessor based on __vector_as_bytebuffer below, which is much more efficient,
+   * assuming your Java program can handle UTF-8 data directly.
+   *
+   * @param offset An `int` index into the Table's ByteBuffer.
+   * @param bb Table ByteBuffer used to read a string at given offset.
+   * @param utf8 decoder that creates a Java `String` from UTF-8 characters.
+   * @return Returns a `String` from the data stored inside the FlatBuffer at `offset`.
+   */
+  protected static String __string(int offset, ByteBuffer bb, Utf8 utf8) {
+    offset += bb.getInt(offset);
+    int length = bb.getInt(offset);
+    return utf8.decodeUtf8(bb, offset + SIZEOF_INT, length);
+  }
+
+  /**
+   * Get the length of a vector.
+   *
+   * @param offset An `int` index into the Table's ByteBuffer.
+   * @return Returns the length of the vector whose offset is stored at `offset`.
+   */
+  protected int __vector_len(int offset) {
+    offset += bb_pos;
+    offset += bb.getInt(offset);
+    return bb.getInt(offset);
+  }
+
+  /**
+   * Get the start data of a vector.
+   *
+   * @param offset An `int` index into the Table's ByteBuffer.
+   * @return Returns the start of the vector data whose offset is stored at `offset`.
+   */
+  protected int __vector(int offset) {
+    offset += bb_pos;
+    return offset + bb.getInt(offset) + SIZEOF_INT;  // data starts after the length
+  }
+
+  /**
+   * Get a whole vector as a ByteBuffer.
+   *
+   * This is efficient, since it only allocates a new {@link ByteBuffer} object,
+   * but does not actually copy the data, it still refers to the same bytes
+   * as the original ByteBuffer. Also useful with nested FlatBuffers, etc.
+   *
+   * @param vector_offset The position of the vector in the byte buffer
+   * @param elem_size The size of each element in the array
+   * @return The {@link ByteBuffer} for the array
+   */
+  protected ByteBuffer __vector_as_bytebuffer(int vector_offset, int elem_size) {
+    int o = __offset(vector_offset);
+    if (o == 0) return null;
+    ByteBuffer bb = this.bb.duplicate().order(ByteOrder.LITTLE_ENDIAN);
+    int vectorstart = __vector(o);
+    bb.position(vectorstart);
+    bb.limit(vectorstart + __vector_len(o) * elem_size);
+    return bb;
+  }
+
+  /**
+   * Initialize vector as a ByteBuffer.
+   *
+   * This is more efficient than using duplicate, since it doesn't copy the data
+   * nor allocattes a new {@link ByteBuffer}, creating no garbage to be collected.
+   *
+   * @param bb The {@link ByteBuffer} for the array
+   * @param vector_offset The position of the vector in the byte buffer
+   * @param elem_size The size of each element in the array
+   * @return The {@link ByteBuffer} for the array
+   */
+  protected ByteBuffer __vector_in_bytebuffer(ByteBuffer bb, int vector_offset, int elem_size) {
+    int o = this.__offset(vector_offset);
+    if (o == 0) return null;
+    int vectorstart = __vector(o);
+    bb.rewind();
+    bb.limit(vectorstart + __vector_len(o) * elem_size);
+    bb.position(vectorstart);
+    return bb;
+  }
+
+  /**
+   * Initialize any Table-derived type to point to the union at the given `offset`.
+   *
+   * @param t A `Table`-derived type that should point to the union at `offset`.
+   * @param offset An `int` index into the Table's ByteBuffer.
+   * @return Returns the Table that points to the union at `offset`.
+   */
+  protected Table __union(Table t, int offset) {
+    return __union(t, offset, bb);
+  }
+
+  /**
+   * Initialize any Table-derived type to point to the union at the given `offset`.
+   *
+   * @param t A `Table`-derived type that should point to the union at `offset`.
+   * @param offset An `int` index into the Table's ByteBuffer.
+   * @param bb Table ByteBuffer used to initialize the object Table-derived type.
+   * @return Returns the Table that points to the union at `offset`.
+   */
+  protected static Table __union(Table t, int offset, ByteBuffer bb) {
+    t.__reset(__indirect(offset, bb), bb);
+    return t;
+  }
+
+  /**
+   * Check if a {@link ByteBuffer} contains a file identifier.
+   *
+   * @param bb A {@code ByteBuffer} to check if it contains the identifier
+   * `ident`.
+   * @param ident A `String` identifier of the FlatBuffer file.
+   * @return True if the buffer contains the file identifier
+   */
+  protected static boolean __has_identifier(ByteBuffer bb, String ident) {
+    if (ident.length() != FILE_IDENTIFIER_LENGTH)
+        throw new AssertionError("FlatBuffers: file identifier must be length " +
+                                 FILE_IDENTIFIER_LENGTH);
+    for (int i = 0; i < FILE_IDENTIFIER_LENGTH; i++) {
+      if (ident.charAt(i) != (char)bb.get(bb.position() + SIZEOF_INT + i)) return false;
+    }
+    return true;
+  }
+
+  /**
+   * Sort tables by the key.
+   *
+   * @param offsets An 'int' indexes of the tables into the bb.
+   * @param bb A {@code ByteBuffer} to get the tables.
+   */
+  protected void sortTables(int[] offsets, final ByteBuffer bb) {
+    Integer[] off = new Integer[offsets.length];
+    for (int i = 0; i < offsets.length; i++) off[i] = offsets[i];
+    java.util.Arrays.sort(off, new java.util.Comparator<Integer>() {
+      public int compare(Integer o1, Integer o2) {
+        return keysCompare(o1, o2, bb);
+      }
+    });
+    for (int i = 0; i < offsets.length; i++) offsets[i] = off[i];
+  }
+
+  /**
+   * Compare two tables by the key.
+   *
+   * @param o1 An 'Integer' index of the first key into the bb.
+   * @param o2 An 'Integer' index of the second key into the bb.
+   * @param bb A {@code ByteBuffer} to get the keys.
+   */
+  protected int keysCompare(Integer o1, Integer o2, ByteBuffer bb) { return 0; }
+
+  /**
+   * Compare two strings in the buffer.
+   *
+   * @param offset_1 An 'int' index of the first string into the bb.
+   * @param offset_2 An 'int' index of the second string into the bb.
+   * @param bb A {@code ByteBuffer} to get the strings.
+   */
+  protected static int compareStrings(int offset_1, int offset_2, ByteBuffer bb) {
+    offset_1 += bb.getInt(offset_1);
+    offset_2 += bb.getInt(offset_2);
+    int len_1 = bb.getInt(offset_1);
+    int len_2 = bb.getInt(offset_2);
+    int startPos_1 = offset_1 + SIZEOF_INT;
+    int startPos_2 = offset_2 + SIZEOF_INT;
+    int len = Math.min(len_1, len_2);
+    for(int i = 0; i < len; i++) {
+      if (bb.get(i + startPos_1) != bb.get(i + startPos_2))
+        return bb.get(i + startPos_1) - bb.get(i + startPos_2);
+    }
+    return len_1 - len_2;
+  }
+
+  /**
+   * Compare string from the buffer with the 'String' object.
+   *
+   * @param offset_1 An 'int' index of the first string into the bb.
+   * @param key Second string as a byte array.
+   * @param bb A {@code ByteBuffer} to get the first string.
+   */
+  protected static int compareStrings(int offset_1, byte[] key, ByteBuffer bb) {
+    offset_1 += bb.getInt(offset_1);
+    int len_1 = bb.getInt(offset_1);
+    int len_2 = key.length;
+    int startPos_1 = offset_1 + Constants.SIZEOF_INT;
+    int len = Math.min(len_1, len_2);
+    for (int i = 0; i < len; i++) {
+      if (bb.get(i + startPos_1) != key[i])
+        return bb.get(i + startPos_1) - key[i];
+    }
+    return len_1 - len_2;
+  }
+
+  /**
+   * Re-init the internal state with an external buffer {@code ByteBuffer} and an offset within.
+   *
+   * This method exists primarily to allow recycling Table instances without risking memory leaks
+   * due to {@code ByteBuffer} references.
+   */
+  protected void __reset(int _i, ByteBuffer _bb) { 
+    bb = _bb;
+    if (bb != null) {
+      bb_pos = _i;
+      vtable_start = bb_pos - bb.getInt(bb_pos);
+      vtable_size = bb.getShort(vtable_start);
+    } else {
+      bb_pos = 0;
+      vtable_start = 0;
+      vtable_size = 0;
+    }
+  }
+
+  /**
+   * Resets the internal state with a null {@code ByteBuffer} and a zero position.
+   *
+   * This method exists primarily to allow recycling Table instances without risking memory leaks
+   * due to {@code ByteBuffer} references. The instance will be unusable until it is assigned
+   * again to a {@code ByteBuffer}.
+   */
+  public void __reset() {
+    __reset(0, null);
+  }
+}
+
+/// @endcond
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/UnionVector.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/UnionVector.java
new file mode 100644
index 00000000..d751ac23
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/UnionVector.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2019 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import static io.objectbox.flatbuffers.Constants.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.Charset;
+
+/**
+ * Helper type for accessing vector of unions.
+ */
+public final class UnionVector extends BaseVector {
+  /**
+   * Assigns vector access object to vector data.
+   *
+   * @param _vector Start data of a vector.
+   * @param _element_size Size of a vector element.
+   * @param _bb Table's ByteBuffer.
+   * @return Returns current vector access object assigned to vector data whose offset is stored at
+   *         `vector`.
+   */
+  public UnionVector __assign(int _vector, int _element_size, ByteBuffer _bb) {
+    __reset(_vector, _element_size, _bb); return this;
+  }
+
+
+  /**
+   * Initialize any Table-derived type to point to the union at the given `index`.
+   *
+   * @param obj A `Table`-derived type that should point to the union at `index`.
+   * @param j An `int` index into the union vector.
+   * @return Returns the Table that points to the union at `index`.
+   */
+  public Table get(Table obj, int j) {
+    return Table.__union(obj, __element(j), bb);
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8.java
new file mode 100644
index 00000000..d1313d45
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import java.nio.ByteBuffer;
+
+import static java.lang.Character.MAX_SURROGATE;
+import static java.lang.Character.MIN_SURROGATE;
+import static java.lang.Character.MIN_HIGH_SURROGATE;
+import static java.lang.Character.MIN_LOW_SURROGATE;
+import static java.lang.Character.MIN_SUPPLEMENTARY_CODE_POINT;
+import static java.lang.Character.isSurrogatePair;
+import static java.lang.Character.toCodePoint;
+
+public abstract class Utf8 {
+
+  /**
+   * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string,
+   * this method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in
+   * both time and space.
+   *
+   * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
+   *     surrogates)
+   */
+  public abstract int encodedLength(CharSequence sequence);
+
+  /**
+   * Encodes the given characters to the target {@link ByteBuffer} using UTF-8 encoding.
+   *
+   * <p>Selects an optimal algorithm based on the type of {@link ByteBuffer} (i.e. heap or direct)
+   * and the capabilities of the platform.
+   *
+   * @param in the source string to be encoded
+   * @param out the target buffer to receive the encoded string.
+   */
+  public abstract void encodeUtf8(CharSequence in, ByteBuffer out);
+
+  /**
+   * Decodes the given UTF-8 portion of the {@link ByteBuffer} into a {@link String}.
+   *
+   * @throws IllegalArgumentException if the input is not valid UTF-8.
+   */
+  public abstract String decodeUtf8(ByteBuffer buffer, int offset, int length);
+
+  private static Utf8 DEFAULT;
+
+  /**
+   * Get the default UTF-8 processor.
+   * @return the default processor
+   */
+  public static Utf8 getDefault() {
+    if (DEFAULT == null) {
+      DEFAULT = new Utf8Safe();
+    }
+    return DEFAULT;
+  }
+
+  /**
+   * Set the default instance of the UTF-8 processor.
+   * @param instance the new instance to use
+   */
+  public static void setDefault(Utf8 instance) {
+    DEFAULT = instance;
+  }
+
+  /**
+   * Encode a Java's CharSequence UTF8 codepoint into a byte array.
+   * @param in CharSequence to be encoded
+   * @param start start position of the first char in the codepoint
+   * @param out byte array of 4 bytes to be filled
+   * @return return the amount of bytes occupied by the codepoint
+   */
+  public static int encodeUtf8CodePoint(CharSequence in, int start, byte[] out) {
+    // utf8 codepoint needs at least 4 bytes
+    assert out.length >= 4;
+
+    final int inLength = in.length();
+    if (start >= inLength) {
+      return 0;
+    }
+
+    char c = in.charAt(start);
+     if (c < 0x80) {
+       // One byte (0xxx xxxx)
+       out[0] = (byte) c;
+       return 1;
+     } else if (c < 0x800) {
+      // Two bytes (110x xxxx 10xx xxxx)
+      out[0] = (byte) (0xC0 | (c >>> 6));
+      out[1] = (byte) (0x80 | (0x3F & c));
+      return 2;
+    } else if (c < MIN_SURROGATE || MAX_SURROGATE < c) {
+      // Three bytes (1110 xxxx 10xx xxxx 10xx xxxx)
+      // Maximum single-char code point is 0xFFFF, 16 bits.
+      out[0] = (byte) (0xE0 | (c >>> 12));
+      out[1] =(byte) (0x80 | (0x3F & (c >>> 6)));
+      out[2] = (byte) (0x80 | (0x3F & c));
+      return 3;
+    } else {
+      // Four bytes (1111 xxxx 10xx xxxx 10xx xxxx 10xx xxxx)
+      // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, four UTF-8
+      // bytes
+      final char low;
+      if (start + 1 == inLength || !isSurrogatePair(c, (low = in.charAt(start+1)))) {
+        throw new UnpairedSurrogateException(start, inLength);
+      }
+      int codePoint = toCodePoint(c, low);
+      out[0] = (byte) ((0xF << 4) | (codePoint >>> 18));
+      out[1] = (byte) (0x80 | (0x3F & (codePoint >>> 12)));
+      out[2] = (byte) (0x80 | (0x3F & (codePoint >>> 6)));
+      out[3] = (byte) (0x80 | (0x3F & codePoint));
+      return 4;
+    }
+  }
+
+  /**
+   * Utility methods for decoding bytes into {@link String}. Callers are responsible for extracting
+   * bytes (possibly using Unsafe methods), and checking remaining bytes. All other UTF-8 validity
+   * checks and codepoint conversion happen in this class.
+   */
+  static class DecodeUtil {
+
+    /**
+     * Returns whether this is a single-byte codepoint (i.e., ASCII) with the form '0XXXXXXX'.
+     */
+    static boolean isOneByte(byte b) {
+      return b >= 0;
+    }
+
+    /**
+     * Returns whether this is a two-byte codepoint with the form '10XXXXXX'.
+     */
+    static boolean isTwoBytes(byte b) {
+      return b < (byte) 0xE0;
+    }
+
+    /**
+     * Returns whether this is a three-byte codepoint with the form '110XXXXX'.
+     */
+    static boolean isThreeBytes(byte b) {
+      return b < (byte) 0xF0;
+    }
+
+    static void handleOneByte(byte byte1, char[] resultArr, int resultPos) {
+      resultArr[resultPos] = (char) byte1;
+    }
+
+    static void handleTwoBytes(
+        byte byte1, byte byte2, char[] resultArr, int resultPos)
+        throws IllegalArgumentException {
+      // Simultaneously checks for illegal trailing-byte in leading position (<= '11000000') and
+      // overlong 2-byte, '11000001'.
+      if (byte1 < (byte) 0xC2) {
+        throw new IllegalArgumentException("Invalid UTF-8: Illegal leading byte in 2 bytes utf");
+      }
+      if (isNotTrailingByte(byte2)) {
+        throw new IllegalArgumentException("Invalid UTF-8: Illegal trailing byte in 2 bytes utf");
+      }
+      resultArr[resultPos] = (char) (((byte1 & 0x1F) << 6) | trailingByteValue(byte2));
+    }
+
+    static void handleThreeBytes(
+        byte byte1, byte byte2, byte byte3, char[] resultArr, int resultPos)
+        throws IllegalArgumentException {
+      if (isNotTrailingByte(byte2)
+              // overlong? 5 most significant bits must not all be zero
+              || (byte1 == (byte) 0xE0 && byte2 < (byte) 0xA0)
+              // check for illegal surrogate codepoints
+              || (byte1 == (byte) 0xED && byte2 >= (byte) 0xA0)
+              || isNotTrailingByte(byte3)) {
+        throw new IllegalArgumentException("Invalid UTF-8");
+      }
+      resultArr[resultPos] = (char)
+                                 (((byte1 & 0x0F) << 12) | (trailingByteValue(byte2) << 6) | trailingByteValue(byte3));
+    }
+
+    static void handleFourBytes(
+        byte byte1, byte byte2, byte byte3, byte byte4, char[] resultArr, int resultPos)
+        throws IllegalArgumentException{
+      if (isNotTrailingByte(byte2)
+              // Check that 1 <= plane <= 16.  Tricky optimized form of:
+              //   valid 4-byte leading byte?
+              // if (byte1 > (byte) 0xF4 ||
+              //   overlong? 4 most significant bits must not all be zero
+              //     byte1 == (byte) 0xF0 && byte2 < (byte) 0x90 ||
+              //   codepoint larger than the highest code point (U+10FFFF)?
+              //     byte1 == (byte) 0xF4 && byte2 > (byte) 0x8F)
+              || (((byte1 << 28) + (byte2 - (byte) 0x90)) >> 30) != 0
+              || isNotTrailingByte(byte3)
+              || isNotTrailingByte(byte4)) {
+        throw new IllegalArgumentException("Invalid UTF-8");
+      }
+      int codepoint = ((byte1 & 0x07) << 18)
+                          | (trailingByteValue(byte2) << 12)
+                          | (trailingByteValue(byte3) << 6)
+                          | trailingByteValue(byte4);
+      resultArr[resultPos] = DecodeUtil.highSurrogate(codepoint);
+      resultArr[resultPos + 1] = DecodeUtil.lowSurrogate(codepoint);
+    }
+
+    /**
+     * Returns whether the byte is not a valid continuation of the form '10XXXXXX'.
+     */
+    private static boolean isNotTrailingByte(byte b) {
+      return b > (byte) 0xBF;
+    }
+
+    /**
+     * Returns the actual value of the trailing byte (removes the prefix '10') for composition.
+     */
+    private static int trailingByteValue(byte b) {
+      return b & 0x3F;
+    }
+
+    private static char highSurrogate(int codePoint) {
+      return (char) ((MIN_HIGH_SURROGATE - (MIN_SUPPLEMENTARY_CODE_POINT >>> 10))
+                         + (codePoint >>> 10));
+    }
+
+    private static char lowSurrogate(int codePoint) {
+      return (char) (MIN_LOW_SURROGATE + (codePoint & 0x3ff));
+    }
+  }
+
+  // These UTF-8 handling methods are copied from Guava's Utf8Unsafe class with a modification to throw
+  // a protocol buffer local exception. This exception is then caught in CodedOutputStream so it can
+  // fallback to more lenient behavior.
+  static class UnpairedSurrogateException extends IllegalArgumentException {
+    UnpairedSurrogateException(int index, int length) {
+      super("Unpaired surrogate at index " + index + " of " + length);
+    }
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8Old.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8Old.java
new file mode 100644
index 00000000..acb91738
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8Old.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2014 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.flatbuffers;
+
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.CharsetEncoder;
+import java.nio.charset.CoderResult;
+import java.nio.charset.StandardCharsets;
+
+/**
+ * This class implements the Utf8 API using the Java Utf8 encoder. Use
+ * Utf8.setDefault(new Utf8Old()); to use it.
+ */
+public class Utf8Old extends Utf8 {
+
+  private static class Cache {
+    final CharsetEncoder encoder;
+    final CharsetDecoder decoder;
+    CharSequence lastInput = null;
+    ByteBuffer lastOutput = null;
+
+    Cache() {
+      encoder = StandardCharsets.UTF_8.newEncoder();
+      decoder = StandardCharsets.UTF_8.newDecoder();
+    }
+  }
+
+  private static final ThreadLocal<Cache> CACHE =
+      ThreadLocal.withInitial(() -> new Cache());
+
+  // Play some games so that the old encoder doesn't pay twice for computing
+  // the length of the encoded string.
+
+  @Override
+  public int encodedLength(CharSequence in) {
+    final Cache cache = CACHE.get();
+    int estimated = (int) (in.length() * cache.encoder.maxBytesPerChar());
+    if (cache.lastOutput == null || cache.lastOutput.capacity() < estimated) {
+      cache.lastOutput = ByteBuffer.allocate(Math.max(128, estimated));
+    }
+    cache.lastOutput.clear();
+    cache.lastInput = in;
+    CharBuffer wrap = (in instanceof CharBuffer) ?
+                          (CharBuffer) in : CharBuffer.wrap(in);
+    CoderResult result = cache.encoder.encode(wrap, cache.lastOutput, true);
+    if (result.isError()) {
+      try {
+        result.throwException();
+      } catch (CharacterCodingException e) {
+        throw new IllegalArgumentException("bad character encoding", e);
+      }
+    }
+    cache.lastOutput.flip();
+    return cache.lastOutput.remaining();
+  }
+
+  @Override
+  public void encodeUtf8(CharSequence in, ByteBuffer out) {
+    final Cache cache = CACHE.get();
+    if (cache.lastInput != in) {
+      // Update the lastOutput to match our input, although flatbuffer should
+      // never take this branch.
+      encodedLength(in);
+    }
+    out.put(cache.lastOutput);
+  }
+
+  @Override
+  public String decodeUtf8(ByteBuffer buffer, int offset, int length) {
+    CharsetDecoder decoder = CACHE.get().decoder;
+    decoder.reset();
+    buffer = buffer.duplicate();
+    buffer.position(offset);
+    buffer.limit(offset + length);
+    try {
+      CharBuffer result = decoder.decode(buffer);
+      return result.toString();
+    } catch (CharacterCodingException e) {
+      throw new IllegalArgumentException("Bad encoding", e);
+    }
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8Safe.java b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8Safe.java
new file mode 100644
index 00000000..0a263ec4
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/flatbuffers/Utf8Safe.java
@@ -0,0 +1,421 @@
+package io.objectbox.flatbuffers;
+
+import java.nio.ByteBuffer;
+import static java.lang.Character.MAX_SURROGATE;
+import static java.lang.Character.MIN_SUPPLEMENTARY_CODE_POINT;
+import static java.lang.Character.MIN_SURROGATE;
+import static java.lang.Character.isSurrogatePair;
+import static java.lang.Character.toCodePoint;
+
+/**
+ * A set of low-level, high-performance static utility methods related
+ * to the UTF-8 character encoding.  This class has no dependencies
+ * outside of the core JDK libraries.
+ *
+ * <p>There are several variants of UTF-8.  The one implemented by
+ * this class is the restricted definition of UTF-8 introduced in
+ * Unicode 3.1, which mandates the rejection of "overlong" byte
+ * sequences as well as rejection of 3-byte surrogate codepoint byte
+ * sequences.  Note that the UTF-8 decoder included in Oracle's JDK
+ * has been modified to also reject "overlong" byte sequences, but (as
+ * of 2011) still accepts 3-byte surrogate codepoint byte sequences.
+ *
+ * <p>The byte sequences considered valid by this class are exactly
+ * those that can be roundtrip converted to Strings and back to bytes
+ * using the UTF-8 charset, without loss: <pre> {@code
+ * Arrays.equals(bytes, new String(bytes, Internal.UTF_8).getBytes(Internal.UTF_8))
+ * }</pre>
+ *
+ * <p>See the Unicode Standard,</br>
+ * Table 3-6. <em>UTF-8 Bit Distribution</em>,</br>
+ * Table 3-7. <em>Well Formed UTF-8 Byte Sequences</em>.
+ */
+final public class Utf8Safe extends Utf8 {
+
+  /**
+   * Returns the number of bytes in the UTF-8-encoded form of {@code sequence}. For a string,
+   * this method is equivalent to {@code string.getBytes(UTF_8).length}, but is more efficient in
+   * both time and space.
+   *
+   * @throws IllegalArgumentException if {@code sequence} contains ill-formed UTF-16 (unpaired
+   *     surrogates)
+   */
+  private static int computeEncodedLength(CharSequence sequence) {
+    // Warning to maintainers: this implementation is highly optimized.
+    int utf16Length = sequence.length();
+    int utf8Length = utf16Length;
+    int i = 0;
+
+    // This loop optimizes for pure ASCII.
+    while (i < utf16Length && sequence.charAt(i) < 0x80) {
+      i++;
+    }
+
+    // This loop optimizes for chars less than 0x800.
+    for (; i < utf16Length; i++) {
+      char c = sequence.charAt(i);
+      if (c < 0x800) {
+        utf8Length += ((0x7f - c) >>> 31);  // branch free!
+      } else {
+        utf8Length += encodedLengthGeneral(sequence, i);
+        break;
+      }
+    }
+
+    if (utf8Length < utf16Length) {
+      // Necessary and sufficient condition for overflow because of maximum 3x expansion
+      throw new IllegalArgumentException("UTF-8 length does not fit in int: "
+                                             + (utf8Length + (1L << 32)));
+    }
+    return utf8Length;
+  }
+
+  private static int encodedLengthGeneral(CharSequence sequence, int start) {
+    int utf16Length = sequence.length();
+    int utf8Length = 0;
+    for (int i = start; i < utf16Length; i++) {
+      char c = sequence.charAt(i);
+      if (c < 0x800) {
+        utf8Length += (0x7f - c) >>> 31; // branch free!
+      } else {
+        utf8Length += 2;
+        // jdk7+: if (Character.isSurrogate(c)) {
+        if (Character.MIN_SURROGATE <= c && c <= Character.MAX_SURROGATE) {
+          // Check that we have a well-formed surrogate pair.
+          int cp = Character.codePointAt(sequence, i);
+          if (cp < MIN_SUPPLEMENTARY_CODE_POINT) {
+            throw new Utf8Safe.UnpairedSurrogateException(i, utf16Length);
+          }
+          i++;
+        }
+      }
+    }
+    return utf8Length;
+  }
+
+  public static String decodeUtf8Array(byte[] bytes, int index, int size) {
+    // Bitwise OR combines the sign bits so any negative value fails the check.
+    if ((index | size | bytes.length - index - size) < 0) {
+      throw new ArrayIndexOutOfBoundsException(
+          String.format("buffer length=%d, index=%d, size=%d", bytes.length, index, size));
+    }
+
+    int offset = index;
+    final int limit = offset + size;
+
+    // The longest possible resulting String is the same as the number of input bytes, when it is
+    // all ASCII. For other cases, this over-allocates and we will truncate in the end.
+    char[] resultArr = new char[size];
+    int resultPos = 0;
+
+    // Optimize for 100% ASCII (Hotspot loves small simple top-level loops like this).
+    // This simple loop stops when we encounter a byte >= 0x80 (i.e. non-ASCII).
+    while (offset < limit) {
+      byte b = bytes[offset];
+      if (!DecodeUtil.isOneByte(b)) {
+        break;
+      }
+      offset++;
+      DecodeUtil.handleOneByte(b, resultArr, resultPos++);
+    }
+
+    while (offset < limit) {
+      byte byte1 = bytes[offset++];
+      if (DecodeUtil.isOneByte(byte1)) {
+        DecodeUtil.handleOneByte(byte1, resultArr, resultPos++);
+        // It's common for there to be multiple ASCII characters in a run mixed in, so add an
+        // extra optimized loop to take care of these runs.
+        while (offset < limit) {
+          byte b = bytes[offset];
+          if (!DecodeUtil.isOneByte(b)) {
+            break;
+          }
+          offset++;
+          DecodeUtil.handleOneByte(b, resultArr, resultPos++);
+        }
+      } else if (DecodeUtil.isTwoBytes(byte1)) {
+        if (offset >= limit) {
+          throw new IllegalArgumentException("Invalid UTF-8");
+        }
+        DecodeUtil.handleTwoBytes(byte1, /* byte2 */ bytes[offset++], resultArr, resultPos++);
+      } else if (DecodeUtil.isThreeBytes(byte1)) {
+        if (offset >= limit - 1) {
+          throw new IllegalArgumentException("Invalid UTF-8");
+        }
+        DecodeUtil.handleThreeBytes(
+            byte1,
+            /* byte2 */ bytes[offset++],
+            /* byte3 */ bytes[offset++],
+            resultArr,
+            resultPos++);
+      } else {
+        if (offset >= limit - 2) {
+          throw new IllegalArgumentException("Invalid UTF-8");
+        }
+        DecodeUtil.handleFourBytes(
+            byte1,
+            /* byte2 */ bytes[offset++],
+            /* byte3 */ bytes[offset++],
+            /* byte4 */ bytes[offset++],
+            resultArr,
+            resultPos++);
+        // 4-byte case requires two chars.
+        resultPos++;
+      }
+    }
+
+    return new String(resultArr, 0, resultPos);
+  }
+
+  public static String decodeUtf8Buffer(ByteBuffer buffer, int offset,
+                                         int length) {
+    // Bitwise OR combines the sign bits so any negative value fails the check.
+    if ((offset | length | buffer.limit() - offset - length) < 0) {
+      throw new ArrayIndexOutOfBoundsException(
+          String.format("buffer limit=%d, index=%d, limit=%d", buffer.limit(),
+              offset, length));
+    }
+
+    final int limit = offset + length;
+
+    // The longest possible resulting String is the same as the number of input bytes, when it is
+    // all ASCII. For other cases, this over-allocates and we will truncate in the end.
+    char[] resultArr = new char[length];
+    int resultPos = 0;
+
+    // Optimize for 100% ASCII (Hotspot loves small simple top-level loops like this).
+    // This simple loop stops when we encounter a byte >= 0x80 (i.e. non-ASCII).
+    while (offset < limit) {
+      byte b = buffer.get(offset);
+      if (!DecodeUtil.isOneByte(b)) {
+        break;
+      }
+      offset++;
+      DecodeUtil.handleOneByte(b, resultArr, resultPos++);
+    }
+
+    while (offset < limit) {
+      byte byte1 = buffer.get(offset++);
+      if (DecodeUtil.isOneByte(byte1)) {
+        DecodeUtil.handleOneByte(byte1, resultArr, resultPos++);
+        // It's common for there to be multiple ASCII characters in a run mixed in, so add an
+        // extra optimized loop to take care of these runs.
+        while (offset < limit) {
+          byte b = buffer.get(offset);
+          if (!DecodeUtil.isOneByte(b)) {
+            break;
+          }
+          offset++;
+          DecodeUtil.handleOneByte(b, resultArr, resultPos++);
+        }
+      } else if (DecodeUtil.isTwoBytes(byte1)) {
+        if (offset >= limit) {
+          throw new IllegalArgumentException("Invalid UTF-8");
+        }
+        DecodeUtil.handleTwoBytes(
+            byte1, /* byte2 */ buffer.get(offset++), resultArr, resultPos++);
+      } else if (DecodeUtil.isThreeBytes(byte1)) {
+        if (offset >= limit - 1) {
+          throw new IllegalArgumentException("Invalid UTF-8");
+        }
+        DecodeUtil.handleThreeBytes(
+            byte1,
+            /* byte2 */ buffer.get(offset++),
+            /* byte3 */ buffer.get(offset++),
+            resultArr,
+            resultPos++);
+      } else {
+        if (offset >= limit - 2) {
+          throw new IllegalArgumentException("Invalid UTF-8");
+        }
+        DecodeUtil.handleFourBytes(
+            byte1,
+            /* byte2 */ buffer.get(offset++),
+            /* byte3 */ buffer.get(offset++),
+            /* byte4 */ buffer.get(offset++),
+            resultArr,
+            resultPos++);
+        // 4-byte case requires two chars.
+        resultPos++;
+      }
+    }
+
+    return new String(resultArr, 0, resultPos);
+  }
+
+  @Override
+  public int encodedLength(CharSequence in) {
+    return computeEncodedLength(in);
+  }
+
+  /**
+   * Decodes the given UTF-8 portion of the {@link ByteBuffer} into a {@link String}.
+   *
+   * @throws IllegalArgumentException if the input is not valid UTF-8.
+   */
+  @Override
+  public String decodeUtf8(ByteBuffer buffer, int offset, int length)
+      throws IllegalArgumentException {
+    if (buffer.hasArray()) {
+      return decodeUtf8Array(buffer.array(), buffer.arrayOffset() + offset, length);
+    } else {
+      return decodeUtf8Buffer(buffer, offset, length);
+    }
+  }
+
+
+  private static void encodeUtf8Buffer(CharSequence in, ByteBuffer out) {
+    final int inLength = in.length();
+    int outIx = out.position();
+    int inIx = 0;
+
+    // Since ByteBuffer.putXXX() already checks boundaries for us, no need to explicitly check
+    // access. Assume the buffer is big enough and let it handle the out of bounds exception
+    // if it occurs.
+    try {
+      // Designed to take advantage of
+      // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
+      for (char c; inIx < inLength && (c = in.charAt(inIx)) < 0x80; ++inIx) {
+        out.put(outIx + inIx, (byte) c);
+      }
+      if (inIx == inLength) {
+        // Successfully encoded the entire string.
+        out.position(outIx + inIx);
+        return;
+      }
+
+      outIx += inIx;
+      for (char c; inIx < inLength; ++inIx, ++outIx) {
+        c = in.charAt(inIx);
+        if (c < 0x80) {
+          // One byte (0xxx xxxx)
+          out.put(outIx, (byte) c);
+        } else if (c < 0x800) {
+          // Two bytes (110x xxxx 10xx xxxx)
+
+          // Benchmarks show put performs better than putShort here (for HotSpot).
+          out.put(outIx++, (byte) (0xC0 | (c >>> 6)));
+          out.put(outIx, (byte) (0x80 | (0x3F & c)));
+        } else if (c < MIN_SURROGATE || MAX_SURROGATE < c) {
+          // Three bytes (1110 xxxx 10xx xxxx 10xx xxxx)
+          // Maximum single-char code point is 0xFFFF, 16 bits.
+
+          // Benchmarks show put performs better than putShort here (for HotSpot).
+          out.put(outIx++, (byte) (0xE0 | (c >>> 12)));
+          out.put(outIx++, (byte) (0x80 | (0x3F & (c >>> 6))));
+          out.put(outIx, (byte) (0x80 | (0x3F & c)));
+        } else {
+          // Four bytes (1111 xxxx 10xx xxxx 10xx xxxx 10xx xxxx)
+
+          // Minimum code point represented by a surrogate pair is 0x10000, 17 bits, four UTF-8
+          // bytes
+          final char low;
+          if (inIx + 1 == inLength || !isSurrogatePair(c, (low = in.charAt(++inIx)))) {
+            throw new UnpairedSurrogateException(inIx, inLength);
+          }
+          // TODO(nathanmittler): Consider using putInt() to improve performance.
+          int codePoint = toCodePoint(c, low);
+          out.put(outIx++, (byte) ((0xF << 4) | (codePoint >>> 18)));
+          out.put(outIx++, (byte) (0x80 | (0x3F & (codePoint >>> 12))));
+          out.put(outIx++, (byte) (0x80 | (0x3F & (codePoint >>> 6))));
+          out.put(outIx, (byte) (0x80 | (0x3F & codePoint)));
+        }
+      }
+
+      // Successfully encoded the entire string.
+      out.position(outIx);
+    } catch (IndexOutOfBoundsException e) {
+      // TODO(nathanmittler): Consider making the API throw IndexOutOfBoundsException instead.
+
+      // If we failed in the outer ASCII loop, outIx will not have been updated. In this case,
+      // use inIx to determine the bad write index.
+      int badWriteIndex = out.position() + Math.max(inIx, outIx - out.position() + 1);
+      throw new ArrayIndexOutOfBoundsException(
+          "Failed writing " + in.charAt(inIx) + " at index " + badWriteIndex);
+    }
+  }
+
+  private static int encodeUtf8Array(CharSequence in, byte[] out,
+                                     int offset, int length) {
+    int utf16Length = in.length();
+    int j = offset;
+    int i = 0;
+    int limit = offset + length;
+    // Designed to take advantage of
+    // https://wikis.oracle.com/display/HotSpotInternals/RangeCheckElimination
+    for (char c; i < utf16Length && i + j < limit && (c = in.charAt(i)) < 0x80; i++) {
+      out[j + i] = (byte) c;
+    }
+    if (i == utf16Length) {
+      return j + utf16Length;
+    }
+    j += i;
+    for (char c; i < utf16Length; i++) {
+      c = in.charAt(i);
+      if (c < 0x80 && j < limit) {
+        out[j++] = (byte) c;
+      } else if (c < 0x800 && j <= limit - 2) { // 11 bits, two UTF-8 bytes
+        out[j++] = (byte) ((0xF << 6) | (c >>> 6));
+        out[j++] = (byte) (0x80 | (0x3F & c));
+      } else if ((c < Character.MIN_SURROGATE || Character.MAX_SURROGATE < c) && j <= limit - 3) {
+        // Maximum single-char code point is 0xFFFF, 16 bits, three UTF-8 bytes
+        out[j++] = (byte) ((0xF << 5) | (c >>> 12));
+        out[j++] = (byte) (0x80 | (0x3F & (c >>> 6)));
+        out[j++] = (byte) (0x80 | (0x3F & c));
+      } else if (j <= limit - 4) {
+        // Minimum code point represented by a surrogate pair is 0x10000, 17 bits,
+        // four UTF-8 bytes
+        final char low;
+        if (i + 1 == in.length()
+                || !Character.isSurrogatePair(c, (low = in.charAt(++i)))) {
+          throw new UnpairedSurrogateException((i - 1), utf16Length);
+        }
+        int codePoint = Character.toCodePoint(c, low);
+        out[j++] = (byte) ((0xF << 4) | (codePoint >>> 18));
+        out[j++] = (byte) (0x80 | (0x3F & (codePoint >>> 12)));
+        out[j++] = (byte) (0x80 | (0x3F & (codePoint >>> 6)));
+        out[j++] = (byte) (0x80 | (0x3F & codePoint));
+      } else {
+        // If we are surrogates and we're not a surrogate pair, always throw an
+        // UnpairedSurrogateException instead of an ArrayOutOfBoundsException.
+        if ((Character.MIN_SURROGATE <= c && c <= Character.MAX_SURROGATE)
+                && (i + 1 == in.length()
+                        || !Character.isSurrogatePair(c, in.charAt(i + 1)))) {
+          throw new UnpairedSurrogateException(i, utf16Length);
+        }
+        throw new ArrayIndexOutOfBoundsException("Failed writing " + c + " at index " + j);
+      }
+    }
+    return j;
+  }
+
+  /**
+   * Encodes the given characters to the target {@link ByteBuffer} using UTF-8 encoding.
+   *
+   * <p>Selects an optimal algorithm based on the type of {@link ByteBuffer} (i.e. heap or direct)
+   * and the capabilities of the platform.
+   *
+   * @param in the source string to be encoded
+   * @param out the target buffer to receive the encoded string.
+   */
+  @Override
+  public void encodeUtf8(CharSequence in, ByteBuffer out) {
+    if (out.hasArray()) {
+      int start = out.arrayOffset();
+      int end = encodeUtf8Array(in, out.array(), start + out.position(),
+          out.remaining());
+      out.position(end - start);
+    } else {
+      encodeUtf8Buffer(in, out);
+    }
+  }
+
+  // These UTF-8 handling methods are copied from Guava's Utf8Unsafe class with
+  // a modification to throw a local exception. This exception can be caught
+  // to fallback to more lenient behavior.
+  static class UnpairedSurrogateException extends IllegalArgumentException {
+    UnpairedSurrogateException(int index, int length) {
+      super("Unpaired surrogate at index " + index + " of " + length);
+    }
+  }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java
index f799f5f3..239195ce 100644
--- a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java
+++ b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelModifier.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,8 @@
 
 package io.objectbox.ideasonly;
 
+import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
+
 public class ModelModifier {
     public class EntityModifier {
         final String schemaName;
@@ -33,10 +35,11 @@ public void remove() {
         }
 
         public PropertyModifier property(String name) {
-            return  new PropertyModifier(this, name);
+            return new PropertyModifier(this, name);
         }
     }
 
+    @SuppressFBWarnings // Class may be static, ignore as this is an idea only.
     public class PropertyModifier {
         final String name;
         final EntityModifier entityModifier;
diff --git a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java
index 6a1d3213..3ff925c8 100644
--- a/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java
+++ b/objectbox-java/src/main/java/io/objectbox/ideasonly/ModelUpdate.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java b/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java
index 9069dd8a..ee8edbbd 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/CallWithHandle.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java b/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java
index e1f094e5..a564af5e 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/CursorFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java b/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java
index 88816ab0..df0fd3db 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/DebugCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@
 import io.objectbox.InternalAccess;
 import io.objectbox.Transaction;
 import io.objectbox.annotation.apihint.Beta;
+import io.objectbox.exception.DbException;
 
 /** Not intended for normal use. */
 @Beta
@@ -40,7 +41,9 @@ public class DebugCursor implements Closeable {
 
     public static DebugCursor create(Transaction tx) {
         long txHandle = InternalAccess.getHandle(tx);
-        return new DebugCursor(tx, nativeCreate(txHandle));
+        long handle = nativeCreate(txHandle);
+        if (handle == 0) throw new DbException("Could not create native debug cursor");
+        return new DebugCursor(tx, handle);
     }
 
     public DebugCursor(Transaction tx, long handle) {
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/Feature.java b/objectbox-java/src/main/java/io/objectbox/internal/Feature.java
new file mode 100644
index 00000000..48fd3544
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/internal/Feature.java
@@ -0,0 +1,34 @@
+package io.objectbox.internal;
+
+/**
+ * Use with {@link io.objectbox.BoxStore#hasFeature(Feature)}.
+ */
+public enum Feature {
+
+    /** Internal feature, not relevant if using ObjectBox through JNI. */
+    RESULT_ARRAY(1),
+
+    /** TimeSeries support (date/date-nano companion ID and other time-series functionality). */
+    TIME_SERIES(2),
+
+    /** Sync client availability. Visit <a href="https://objectbox.io/sync">the ObjectBox Sync website</a> for more details. */
+    SYNC(3),
+
+    /** Check whether debug log can be enabled during runtime. */
+    DEBUG_LOG(4),
+
+    /** HTTP server with a database browser. */
+    ADMIN(5),
+
+    /** Trees & GraphQL support */
+    TREES(6),
+
+    /** Embedded Sync server availability. */
+    SYNC_SERVER(7);
+
+    public final int id;
+
+    Feature(int id) {
+        this.id = id;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java b/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java
index 36c0e5eb..a2bb6568 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/IdGetter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java b/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java
index af6df829..6da9649a 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/JniTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java
index 39afb44a..8288a1d4 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryLoader.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,21 +16,28 @@
 
 package io.objectbox.internal;
 
-import org.greenrobot.essentials.io.IoUtils;
-
 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
+import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
 import java.io.OutputStream;
+import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.net.URL;
 import java.net.URLConnection;
+import java.nio.charset.Charset;
+import java.util.Arrays;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
 
 import io.objectbox.BoxStore;
+import org.greenrobot.essentials.io.IoUtils;
 
 /**
  * Separate class, so we can mock BoxStore.
@@ -55,21 +62,24 @@ public class NativeLibraryLoader {
         // may provide them on non-Android devices
         final boolean android = vendor.contains("Android");
         if (!android) {
-            String cpuArchPostfix = "-" + getCpuArch();
-            if (osName.contains("windows")) {
+            if (osName.contains("mac")) {
                 isLinux = false;
-                libname += "-windows" + cpuArchPostfix;
-                filename = libname + ".dll";
-                checkUnpackLib(filename);
-            } else if (osName.contains("linux")) {
-                libname += "-linux" + cpuArchPostfix;
-                filename = "lib" + libname + ".so";
-                checkUnpackLib(filename);
-            } else if (osName.contains("mac")) {
-                isLinux = false;
-                libname += "-macos" + cpuArchPostfix;
+                // Note: for macOS using universal library supporting x64 and arm64
+                libname += "-macos";
                 filename = "lib" + libname + ".dylib";
                 checkUnpackLib(filename);
+            } else {
+                String cpuArchPostfix = "-" + getCpuArch();
+                if (osName.contains("windows")) {
+                    isLinux = false;
+                    libname += "-windows" + cpuArchPostfix;
+                    filename = libname + ".dll";
+                    checkUnpackLib(filename);
+                } else if (osName.contains("linux")) {
+                    libname += "-linux" + cpuArchPostfix;
+                    filename = "lib" + libname + ".so";
+                    checkUnpackLib(filename);
+                }
             }
         }
         try {
@@ -101,15 +111,34 @@ public class NativeLibraryLoader {
             }
         } catch (UnsatisfiedLinkError e) {
             String osArch = System.getProperty("os.arch");
-            String sunArch = System.getProperty("sun.arch.data.model");
-            String message = String.format(
-                    "Loading ObjectBox native library failed: vendor=%s,os=%s,os.arch=%s,sun.arch=%s,android=%s,linux=%s",
-                    vendor, osName, osArch, sunArch, android, isLinux
-            );
+            String message;
+            if (android) {
+                message = String.format(
+                        "[ObjectBox] Android failed to load native library," +
+                                " check your APK/App Bundle includes a supported ABI or use ReLinker" +
+                                " https://docs.objectbox.io/android/app-bundle-and-split-apk" +
+                                " (vendor=%s,os=%s,os.arch=%s,SUPPORTED_ABIS=%s)",
+                        vendor, osName, osArch, getSupportedABIsAndroid()
+                );
+            } else {
+                String sunArch = System.getProperty("sun.arch.data.model");
+                message = String.format(
+                        "[ObjectBox] Loading native library failed, please report this to us: " +
+                                "vendor=%s,os=%s,os.arch=%s,model=%s,linux=%s,machine=%s",
+                        vendor, osName, osArch, sunArch, isLinux, getCpuArchOSOrNull()
+                );
+            }
             throw new LinkageError(message, e); // UnsatisfiedLinkError does not allow a cause; use its super class
         }
     }
 
+    /**
+     * Get CPU architecture of the JVM (Note: this can not be used for Android, Android decides arch on its own
+     * and looks for library in appropriately named folder).
+     * <p>
+     * Note that this may not be the architecture of the actual hardware
+     * (e.g. when running a x86 JVM on an amd64 machine).
+     */
     private static String getCpuArch() {
         String osArch = System.getProperty("os.arch");
         String cpuArch = null;
@@ -119,34 +148,71 @@ private static String getCpuArch() {
                 cpuArch = "x64";
             } else if (osArch.equalsIgnoreCase("x86")) {
                 cpuArch = "x86";
+            } else if ("aarch64".equals(osArch) || osArch.startsWith("armv8") || osArch.startsWith("arm64")) {
+                // 64-bit ARM
+                cpuArch = "arm64";
             } else if (osArch.startsWith("arm")) {
-                switch (osArch) {
-                    case "armv7":
-                    case "armv7l":
-                    case "armeabi-v7a": // os.arch "armeabi-v7a" might be Android only, but let's try anyway...
-                        cpuArch = "armv7";
-                        break;
-                    case "arm64-v8a":
-                        cpuArch = "arm64";
-                        break;
-                    case "armv6":
-                        cpuArch = "armv6";
-                        break;
-                    default:
-                        cpuArch = "armv6";  // Lowest version we support
-                        System.err.println("Unknown os.arch \"" + osArch + "\" - ObjectBox is defaulting to " + cpuArch);
-                        break;
+                // 32-bit ARM
+                if (osArch.startsWith("armv7") || osArch.startsWith("armeabi-v7")) {
+                    cpuArch = "armv7";
+                } else if (osArch.startsWith("armv6")) {
+                    cpuArch = "armv6";
+                } else if ("arm".equals(osArch)) {
+                    // JVM may just report "arm" for any 32-bit ARM, so try to check with OS.
+                    String cpuArchOSOrNull = getCpuArchOSOrNull();
+                    if (cpuArchOSOrNull != null) {
+                        String cpuArchOS = cpuArchOSOrNull.toLowerCase();
+                        if (cpuArchOS.startsWith("armv7")) {
+                            cpuArch = "armv7";
+                        } else if (cpuArchOS.startsWith("armv6")) {
+                            cpuArch = "armv6";
+                        } // else use fall back below.
+                    } // else use fall back below.
+                }
+                if (cpuArch == null) {
+                    // Fall back to lowest supported 32-bit ARM version.
+                    cpuArch = "armv6";
+                    System.err.printf("[ObjectBox] 32-bit ARM os.arch unknown (will use %s), " +
+                                    "please report this to us: os.arch=%s, machine=%s%n",
+                            cpuArch, osArch, getCpuArchOSOrNull());
                 }
             }
         }
+        // If os.arch is not covered above try a x86 version based on JVM bit-ness.
         if (cpuArch == null) {
             String sunArch = System.getProperty("sun.arch.data.model");
-            cpuArch = "32".equals(sunArch) ? "x86" : "x64";
-            System.err.println("Unknown os.arch \"" + osArch + "\" - ObjectBox is defaulting to " + cpuArch);
+            if ("64".equals(sunArch)) {
+                cpuArch = "x64";
+            } else if ("32".equals(sunArch)) {
+                cpuArch = "x86";
+            } else {
+                cpuArch = "unknown";
+            }
+            System.err.printf("[ObjectBox] os.arch unknown (will use %s), " +
+                            "please report this to us: os.arch=%s, model=%s, machine=%s%n",
+                    cpuArch, osArch, sunArch, getCpuArchOSOrNull());
         }
         return cpuArch;
     }
 
+    /**
+     * Get architecture using operating system tools. Currently only Linux is supported (using uname).
+     */
+    @Nullable
+    private static String getCpuArchOSOrNull() {
+        String archOrNull = null;
+        try {
+            // Linux
+            Process exec = Runtime.getRuntime().exec("uname -m");
+            BufferedReader reader = new BufferedReader(
+                    new InputStreamReader(exec.getInputStream(), Charset.defaultCharset()));
+            archOrNull = reader.readLine();
+            reader.close();
+        } catch (Exception ignored) {
+        }
+        return archOrNull;
+    }
+
     private static void checkUnpackLib(String filename) {
         String path = "/native/" + filename;
         URL resource = NativeLibraryLoader.class.getResource(path);
@@ -213,6 +279,32 @@ private static boolean loadLibraryAndroid() {
         return true;
     }
 
+    /**
+     * Return a string containing a list of ABIs that are supported by the current Android device.
+     * If the Android device is below API level 21 (Android 5) or if looking up the value fails,
+     * returns an empty string.
+     */
+    @Nonnull
+    private static String getSupportedABIsAndroid() {
+        String[] supportedAbis = null;
+        //noinspection TryWithIdenticalCatches
+        try {
+            Class<?> build = Class.forName("android.os.Build");
+            Field supportedAbisField = build.getField("SUPPORTED_ABIS");
+            supportedAbis = (String[]) supportedAbisField.get(null);
+        } catch (NoSuchFieldException ignored) {
+        } catch (IllegalAccessException ignored) {
+        } catch (ClassNotFoundException ignored) {
+        }
+        // note: can't use multi-catch (would compile to ReflectiveOperationException, is K+ (19+) on Android)
+
+        if (supportedAbis != null) {
+            return Arrays.toString(supportedAbis);
+        } else {
+            return "";
+        }
+    }
+
     public static void ensureLoaded() {
     }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryUtils.java b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryUtils.java
new file mode 100644
index 00000000..0dcc5145
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/internal/NativeLibraryUtils.java
@@ -0,0 +1,66 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.internal;
+
+
+import io.objectbox.BoxStore;
+import io.objectbox.exception.FeatureNotAvailableException;
+
+/**
+ * Provides utility methods related to the platform-specific database library.
+ */
+public class NativeLibraryUtils {
+
+    private static final String FEATURE_NOT_AVAIL_TEMPLATE =
+            "The included ObjectBox database library does not include the %s feature." +
+                    " Please visit %s for options.";
+    private static final String URL_SYNC_LANDING_PAGE = "https://objectbox.io/sync/";
+
+    private NativeLibraryUtils() {
+    }
+
+    /**
+     * If {@link BoxStore#hasFeature(Feature)} returns false, throws a
+     * {@link FeatureNotAvailableException} with a unified, helpful message.
+     *
+     * @param feature the feature to check for
+     * @param featureName a user-friendly name for the feature to use in the message
+     * @param infoUrl the URL where the user can learn about options to get that feature
+     */
+    private static void checkHasFeature(Feature feature, String featureName, String infoUrl)
+            throws FeatureNotAvailableException {
+        if (!BoxStore.hasFeature(feature)) {
+            throw new FeatureNotAvailableException(
+                    String.format(FEATURE_NOT_AVAIL_TEMPLATE, featureName, infoUrl));
+        }
+    }
+
+    /**
+     * Calls {@link #checkHasFeature} with {@link Feature#SYNC}.
+     */
+    public static void checkHasFeature() {
+        checkHasFeature(Feature.SYNC, "Sync", URL_SYNC_LANDING_PAGE);
+    }
+
+    /**
+     * Calls {@link #checkHasFeature} with {@link Feature#SYNC_SERVER}.
+     */
+    public static void checkHasSyncServerFeature() {
+        checkHasFeature(Feature.SYNC_SERVER, "Sync Server", URL_SYNC_LANDING_PAGE);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java b/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java
index 41b2ccdd..29bafec2 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ObjectBoxThreadPool.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,10 +33,11 @@
  *     <li>Reduce keep-alive time for threads to 20 seconds</li>
  *     <li>Uses a ThreadFactory to name threads like "ObjectBox-1-Thread-1"</li>
  * </ul>
- *
  */
 @Internal
 public class ObjectBoxThreadPool extends ThreadPoolExecutor {
+
+    public static final String THREAD_NAME_PREFIX = "ObjectBox-";
     private final BoxStore boxStore;
 
     public ObjectBoxThreadPool(BoxStore boxStore) {
@@ -55,7 +56,7 @@ static class ObjectBoxThreadFactory implements ThreadFactory {
         private static final AtomicInteger POOL_COUNT = new AtomicInteger();
 
         private final ThreadGroup group;
-        private final String namePrefix = "ObjectBox-" + POOL_COUNT.incrementAndGet() + "-Thread-";
+        private final String namePrefix = THREAD_NAME_PREFIX + POOL_COUNT.incrementAndGet() + "-Thread-";
         private final AtomicInteger threadCount = new AtomicInteger();
 
         ObjectBoxThreadFactory() {
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java b/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java
index 3176431c..36ad79b2 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ReflectionCache.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java b/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java
index 8eb29102..8038f741 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ToManyGetter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,6 @@
 import io.objectbox.annotation.apihint.Internal;
 
 @Internal
-public interface ToManyGetter<SOURCE> extends Serializable {
-    <TARGET> List<TARGET> getToMany(SOURCE object);
+public interface ToManyGetter<SOURCE, TARGET> extends Serializable {
+    List<TARGET> getToMany(SOURCE object);
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java b/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java
index 51c70e5c..e435171e 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/ToOneGetter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,6 @@
 import io.objectbox.relation.ToOne;
 
 @Internal
-public interface ToOneGetter<SOURCE> extends Serializable {
-    <TARGET> ToOne<TARGET> getToOne(SOURCE object);
+public interface ToOneGetter<SOURCE, TARGET> extends Serializable {
+    ToOne<TARGET> getToOne(SOURCE object);
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/internal/package-info.java b/objectbox-java/src/main/java/io/objectbox/internal/package-info.java
index b77731f3..4ac0203a 100644
--- a/objectbox-java/src/main/java/io/objectbox/internal/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/internal/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java b/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java
index d6e8909c..3c0b3201 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/EntityFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,16 +21,27 @@
 /**
  * Not really an enum, but binary flags to use across languages
  */
+@SuppressWarnings("unused")
 public final class EntityFlags {
   private EntityFlags() { }
   /**
    * Use the default (no arguments) constructor to create entities
    */
   public static final int USE_NO_ARG_CONSTRUCTOR = 1;
-
-  // Private to protect contents from getting modified.
-  private static final String[] names = { "USE_NO_ARG_CONSTRUCTOR", };
-
-  public static String name(int e) { return names[e - USE_NO_ARG_CONSTRUCTOR]; }
+  /**
+   * Enable "data synchronization" for this entity type: objects will be synced with other stores over the network.
+   * It's possible to have local-only (non-synced) types and synced types in the same store (schema/data model).
+   */
+  public static final int SYNC_ENABLED = 2;
+  /**
+   * Makes object IDs for a synced types (SYNC_ENABLED is set) global.
+   * By default (not using this flag), the 64 bit object IDs have a local scope and are not unique globally.
+   * This flag tells ObjectBox to treat object IDs globally and thus no ID mapping (local <-> global) is performed.
+   * Often this is used with assignable IDs (ID_SELF_ASSIGNABLE property flag is set) and some special ID scheme.
+   * Note: typically you won't do this with automatically assigned IDs, set by the local ObjectBox store.
+   *       Two devices would likely overwrite each other's object during sync as object IDs are prone to collide.
+   *       It might be OK if you can somehow ensure that only a single device will create new IDs.
+   */
+  public static final int SHARED_GLOBAL_IDS = 4;
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ExternalPropertyType.java b/objectbox-java/src/main/java/io/objectbox/model/ExternalPropertyType.java
new file mode 100644
index 00000000..583b58ef
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/ExternalPropertyType.java
@@ -0,0 +1,161 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+/**
+ * A property type of an external system (e.g. another database) that has no default mapping to an ObjectBox type.
+ * External property types numeric values start at 100 to avoid overlaps with ObjectBox's PropertyType.
+ * (And if we ever support one of these as a primary type, we could share the numeric value?)
+ */
+@SuppressWarnings("unused")
+public final class ExternalPropertyType {
+  private ExternalPropertyType() { }
+  /**
+   * Not a real type: represents uninitialized state and can be used for forward compatibility.
+   */
+  public static final short Unknown = 0;
+  /**
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation, little endian (16 bytes)
+   */
+  public static final short Int128 = 100;
+  public static final short Reserved1 = 101;
+  /**
+   * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+   * ObjectBox uses the UUIDv7 scheme (timestamp + random) to create new UUIDs.
+   * UUIDv7 is a good choice for database keys as it's mostly sequential and encodes a timestamp.
+   * However, if keys are used externally, consider UuidV4 for better privacy by not exposing any time information.
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (16 bytes)
+   */
+  public static final short Uuid = 102;
+  /**
+   * IEEE 754 decimal128 type, e.g. supported by MongoDB
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (16 bytes)
+   */
+  public static final short Decimal128 = 103;
+  /**
+   * UUID represented as a string of 36 characters, e.g. "019571b4-80e3-7516-a5c1-5f1053d23fff".
+   * For efficient storage, consider the Uuid type instead, which occupies only 16 bytes (20 bytes less).
+   * This type may still be a convenient alternative as the string type is widely supported and more human-readable.
+   * In accordance to standards, new UUIDs generated by ObjectBox use lowercase hexadecimal digits.
+   * Representing type: String
+   */
+  public static final short UuidString = 104;
+  /**
+   * A UUID (Universally Unique Identifier) as defined by RFC 9562.
+   * ObjectBox uses the UUIDv4 scheme (completely random) to create new UUIDs.
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (16 bytes)
+   */
+  public static final short UuidV4 = 105;
+  /**
+   * Like UuidString, but using the UUIDv4 scheme (completely random) to create new UUID.
+   * Representing type: String
+   */
+  public static final short UuidV4String = 106;
+  /**
+   * A key/value map; e.g. corresponds to a JSON object or a MongoDB document (although not keeping the key order).
+   * Unlike the Flex type, this must contain a map value (e.g. not a vector or a scalar).
+   * Representing type: Flex
+   * Encoding: Flex
+   */
+  public static final short FlexMap = 107;
+  /**
+   * A vector (aka list or array) of flexible elements; e.g. corresponds to a JSON array or a MongoDB array.
+   * Unlike the Flex type, this must contain a vector value (e.g. not a map or a scalar).
+   * Representing type: Flex
+   * Encoding: Flex
+   */
+  public static final short FlexVector = 108;
+  /**
+   * Placeholder (not yet used) for a JSON document.
+   * Representing type: String
+   */
+  public static final short Json = 109;
+  /**
+   * Placeholder (not yet used) for a BSON document.
+   * Representing type: ByteVector
+   */
+  public static final short Bson = 110;
+  /**
+   * JavaScript source code
+   * Representing type: String
+   */
+  public static final short JavaScript = 111;
+  /**
+   * A JSON string that is converted to a native "complex" representation in the external system.
+   * For example in MongoDB, embedded/nested documents are converted to a JSON string in ObjectBox and vice versa.
+   * This allows a quick and simple way to work with non-normalized data from MongoDB in ObjectBox.
+   * Alternatively, you can use FlexMap and FlexVector to map to language primitives (e.g. maps with string keys;
+   * not supported by all ObjectBox languages yet).
+   * For MongoDB, (nested) documents and arrays are supported.
+   * Note that this is very close to the internal representation, e.g. the key order is preserved (unlike Flex).
+   * Representing type: String
+   */
+  public static final short JsonToNative = 112;
+  public static final short Reserved6 = 113;
+  public static final short Reserved7 = 114;
+  public static final short Reserved8 = 115;
+  /**
+   * A vector (array) of Int128 values
+   */
+  public static final short Int128Vector = 116;
+  public static final short Reserved9 = 117;
+  /**
+   * A vector (array) of UUID values
+   */
+  public static final short UuidVector = 118;
+  public static final short Reserved10 = 119;
+  public static final short Reserved11 = 120;
+  public static final short Reserved12 = 121;
+  public static final short Reserved13 = 122;
+  /**
+   * The 12-byte ObjectId type in MongoDB
+   * Representing type: ByteVector
+   * Encoding: 1:1 binary representation (12 bytes)
+   */
+  public static final short MongoId = 123;
+  /**
+   * A vector (array) of MongoId values
+   */
+  public static final short MongoIdVector = 124;
+  /**
+   * Representing type: Long
+   * Encoding: Two unsigned 32-bit integers merged into a 64-bit integer.
+   */
+  public static final short MongoTimestamp = 125;
+  /**
+   * Representing type: ByteVector
+   * Encoding: 3 zero bytes (reserved, functions as padding), fourth byte is the sub-type,
+   * followed by the binary data.
+   */
+  public static final short MongoBinary = 126;
+  /**
+   * Representing type: string vector with 2 elements (index 0: pattern, index 1: options)
+   * Encoding: 1:1 string representation
+   */
+  public static final short MongoRegex = 127;
+
+  public static final String[] names = { "Unknown", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "Int128", "Reserved1", "Uuid", "Decimal128", "UuidString", "UuidV4", "UuidV4String", "FlexMap", "FlexVector", "Json", "Bson", "JavaScript", "JsonToNative", "Reserved6", "Reserved7", "Reserved8", "Int128Vector", "Reserved9", "UuidVector", "Reserved10", "Reserved11", "Reserved12", "Reserved13", "MongoId", "MongoIdVector", "MongoTimestamp", "MongoBinary", "MongoRegex", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/HnswDistanceType.java b/objectbox-java/src/main/java/io/objectbox/model/HnswDistanceType.java
new file mode 100644
index 00000000..7d48ca98
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/HnswDistanceType.java
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+/**
+ * The distance algorithm used by an HNSW index (vector search).
+ */
+@SuppressWarnings("unused")
+public final class HnswDistanceType {
+  private HnswDistanceType() { }
+  /**
+   * Not a real type, just best practice (e.g. forward compatibility)
+   */
+  public static final short Unknown = 0;
+  /**
+   * The default; typically "Euclidean squared" internally.
+   */
+  public static final short Euclidean = 1;
+  /**
+   * Cosine similarity compares two vectors irrespective of their magnitude (compares the angle of two vectors).
+   * Often used for document or semantic similarity.
+   * Value range: 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+   */
+  public static final short Cosine = 2;
+  /**
+   * For normalized vectors (vector length == 1.0), the dot product is equivalent to the cosine similarity.
+   * Because of this, the dot product is often preferred as it performs better.
+   * Value range (normalized vectors): 0.0 - 2.0 (0.0: same direction, 1.0: orthogonal, 2.0: opposite direction)
+   */
+  public static final short DotProduct = 3;
+  /**
+   * For geospatial coordinates aka latitude/longitude pairs.
+   * Note, that the vector dimension must be 2, with the latitude being the first element and longitude the second.
+   * Internally, this uses haversine distance.
+   */
+  public static final short Geo = 6;
+  /**
+   * A custom dot product similarity measure that does not require the vectors to be normalized.
+   * Note: this is no replacement for cosine similarity (like DotProduct for normalized vectors is).
+   * The non-linear conversion provides a high precision over the entire float range (for the raw dot product).
+   * The higher the dot product, the lower the distance is (the nearer the vectors are).
+   * The more negative the dot product, the higher the distance is (the farther the vectors are).
+   * Value range: 0.0 - 2.0 (nonlinear; 0.0: nearest, 1.0: orthogonal, 2.0: farthest)
+   */
+  public static final short DotProductNonNormalized = 10;
+
+  public static final String[] names = { "Unknown", "Euclidean", "Cosine", "DotProduct", "", "", "Geo", "", "", "", "DotProductNonNormalized", };
+
+  public static String name(int e) { return names[e]; }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/HnswFlags.java b/objectbox-java/src/main/java/io/objectbox/model/HnswFlags.java
new file mode 100644
index 00000000..39f7c6e2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/HnswFlags.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+/**
+ * Flags as a part of the HNSW configuration.
+ */
+@SuppressWarnings("unused")
+public final class HnswFlags {
+  private HnswFlags() { }
+  /**
+   * Enables debug logs.
+   */
+  public static final int DebugLogs = 1;
+  /**
+   * Enables "high volume" debug logs, e.g. individual gets/puts.
+   */
+  public static final int DebugLogsDetailed = 2;
+  /**
+   * Padding for SIMD is enabled by default, which uses more memory but may be faster. This flag turns it off.
+   */
+  public static final int VectorCacheSimdPaddingOff = 4;
+  /**
+   * If the speed of removing nodes becomes a concern in your use case, you can speed it up by setting this flag.
+   * By default, repairing the graph after node removals creates more connections to improve the graph's quality.
+   * The extra costs for this are relatively low (e.g. vs. regular indexing), and thus the default is recommended.
+   */
+  public static final int ReparationLimitCandidates = 8;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/HnswParams.java b/objectbox-java/src/main/java/io/objectbox/model/HnswParams.java
new file mode 100644
index 00000000..582a770e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/model/HnswParams.java
@@ -0,0 +1,136 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.model;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Parameters to configure HNSW-based approximate nearest neighbor (ANN) search.
+ * Some of the parameters can influence index construction and searching.
+ * Changing these values causes re-indexing, which can take a while due to the complex nature of HNSW.
+ */
+@SuppressWarnings("unused")
+public final class HnswParams extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static HnswParams getRootAsHnswParams(ByteBuffer _bb) { return getRootAsHnswParams(_bb, new HnswParams()); }
+  public static HnswParams getRootAsHnswParams(ByteBuffer _bb, HnswParams obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public HnswParams __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * Dimensions of vectors; vector data with less dimensions are ignored.
+   * Vectors with more dimensions than specified here are only evaluated up to the given dimension value.
+   * Changing this value causes re-indexing.
+   */
+  public long dimensions() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Aka "M": the max number of connections per node (default: 30).
+   * Higher numbers increase the graph connectivity, which can lead to more accurate search results.
+   * However, higher numbers also increase the indexing time and resource usage.
+   * Try e.g. 16 for faster but less accurate results, or 64 for more accurate results.
+   * Changing this value causes re-indexing.
+   */
+  public long neighborsPerNode() { int o = __offset(6); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Aka "efConstruction": the number of neighbor searched for while indexing (default: 100).
+   * The higher the value, the more accurate the search, but the longer the indexing.
+   * If indexing time is not a major concern, a value of at least 200 is recommended to improve search quality.
+   * Changing this value causes re-indexing.
+   */
+  public long indexingSearchCount() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  public long flags() { int o = __offset(10); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The distance type used for the HNSW index; if none is given, the default Euclidean is used.
+   * Changing this value causes re-indexing.
+   */
+  public int distanceType() { int o = __offset(12); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * When repairing the graph after a node was removed, this gives the probability of adding backlinks to the
+   * repaired neighbors.
+   * The default is 1.0 (aka "always") as this should be worth a bit of extra costs as it improves the graph's
+   * quality.
+   */
+  public float reparationBacklinkProbability() { int o = __offset(14); return o != 0 ? bb.getFloat(o + bb_pos) : 0.0f; }
+  /**
+   * A non-binding hint at the maximum size of the vector cache in KB (default: 2097152 or 2 GB/GiB).
+   * The actual size max cache size may be altered according to device and/or runtime settings.
+   * The vector cache is used to store vectors in memory to speed up search and indexing.
+   * Note 1: cache chunks are allocated only on demand, when they are actually used.
+   *         Thus, smaller datasets will use less memory.
+   * Note 2: the cache is for one specific HNSW index; e.g. each index has its own cache.
+   * Note 3: the memory consumption can temporarily exceed the cache size,
+   *         e.g. for large changes, it can double due to multi-version transactions.
+   */
+  public long vectorCacheHintSizeKb() { int o = __offset(16); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+
+  public static int createHnswParams(FlatBufferBuilder builder,
+      long dimensions,
+      long neighborsPerNode,
+      long indexingSearchCount,
+      long flags,
+      int distanceType,
+      float reparationBacklinkProbability,
+      long vectorCacheHintSizeKb) {
+    builder.startTable(7);
+    HnswParams.addVectorCacheHintSizeKb(builder, vectorCacheHintSizeKb);
+    HnswParams.addReparationBacklinkProbability(builder, reparationBacklinkProbability);
+    HnswParams.addFlags(builder, flags);
+    HnswParams.addIndexingSearchCount(builder, indexingSearchCount);
+    HnswParams.addNeighborsPerNode(builder, neighborsPerNode);
+    HnswParams.addDimensions(builder, dimensions);
+    HnswParams.addDistanceType(builder, distanceType);
+    return HnswParams.endHnswParams(builder);
+  }
+
+  public static void startHnswParams(FlatBufferBuilder builder) { builder.startTable(7); }
+  public static void addDimensions(FlatBufferBuilder builder, long dimensions) { builder.addInt(0, (int) dimensions, (int) 0L); }
+  public static void addNeighborsPerNode(FlatBufferBuilder builder, long neighborsPerNode) { builder.addInt(1, (int) neighborsPerNode, (int) 0L); }
+  public static void addIndexingSearchCount(FlatBufferBuilder builder, long indexingSearchCount) { builder.addInt(2, (int) indexingSearchCount, (int) 0L); }
+  public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(3, (int) flags, (int) 0L); }
+  public static void addDistanceType(FlatBufferBuilder builder, int distanceType) { builder.addShort(4, (short) distanceType, (short) 0); }
+  public static void addReparationBacklinkProbability(FlatBufferBuilder builder, float reparationBacklinkProbability) { builder.addFloat(5, reparationBacklinkProbability, 0.0f); }
+  public static void addVectorCacheHintSizeKb(FlatBufferBuilder builder, long vectorCacheHintSizeKb) { builder.addLong(6, vectorCacheHintSizeKb, 0L); }
+  public static int endHnswParams(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public HnswParams get(int j) { return get(new HnswParams(), j); }
+    public HnswParams get(HnswParams obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/model/IdUid.java b/objectbox-java/src/main/java/io/objectbox/model/IdUid.java
index 9882f3b4..278a551e 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/IdUid.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/IdUid.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,15 +18,27 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import com.google.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
-@SuppressWarnings("unused")
 /**
  * ID tuple: besides the main ID there is also a UID for verification
  */
+@SuppressWarnings("unused")
 public final class IdUid extends Struct {
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
   public IdUid __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
@@ -42,7 +54,7 @@ public static int createIdUid(FlatBufferBuilder builder, long id, long uid) {
     builder.prep(8, 16);
     builder.putLong(uid);
     builder.pad(4);
-    builder.putInt((int)id);
+    builder.putInt((int) id);
     return builder.offset();
   }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/model/Model.java b/objectbox-java/src/main/java/io/objectbox/model/Model.java
index 57e258fe..9d16d67a 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/Model.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/Model.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,20 +18,32 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import com.google.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
-@SuppressWarnings("unused")
 /**
  * A model describes all entities and other meta data.
  * The current model of an app is synced against ObjectBox's persisted schema.
  * The model itself is not persisted, and thus may change as long as both ends are consistent (Java and native).
  * There could be multiple models/schemas (one dbi per schema) in the future.
  */
+@SuppressWarnings("unused")
 public final class Model extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static Model getRootAsModel(ByteBuffer _bb) { return getRootAsModel(_bb, new Model()); }
   public static Model getRootAsModel(ByteBuffer _bb, Model obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -64,9 +76,20 @@ public final class Model extends Table {
   public io.objectbox.model.IdUid lastSequenceId(io.objectbox.model.IdUid obj) { int o = __offset(16); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
   public io.objectbox.model.IdUid lastRelationId() { return lastRelationId(new io.objectbox.model.IdUid()); }
   public io.objectbox.model.IdUid lastRelationId(io.objectbox.model.IdUid obj) { int o = __offset(18); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
+  /**
+   * Hash of the model/schema; usually want to check hashes before even creating a model and thus avoiding creating
+   * the model altogether. But, at least for now, let language bindings provide it via the model optionally.
+   * We use SipHash 128 (16 bytes).
+   */
+  public int hash(int j) { int o = __offset(20); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int hashLength() { int o = __offset(20); return o != 0 ? __vector_len(o) : 0; }
+  public ByteVector hashVector() { return hashVector(new ByteVector()); }
+  public ByteVector hashVector(ByteVector obj) { int o = __offset(20); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer hashAsByteBuffer() { return __vector_as_bytebuffer(20, 1); }
+  public ByteBuffer hashInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 20, 1); }
 
-  public static void startModel(FlatBufferBuilder builder) { builder.startTable(8); }
-  public static void addModelVersion(FlatBufferBuilder builder, long modelVersion) { builder.addInt(0, (int)modelVersion, (int)0L); }
+  public static void startModel(FlatBufferBuilder builder) { builder.startTable(9); }
+  public static void addModelVersion(FlatBufferBuilder builder, long modelVersion) { builder.addInt(0, (int) modelVersion, (int) 0L); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
   public static void addVersion(FlatBufferBuilder builder, long version) { builder.addLong(2, version, 0L); }
   public static void addEntities(FlatBufferBuilder builder, int entitiesOffset) { builder.addOffset(3, entitiesOffset, 0); }
@@ -76,6 +99,10 @@ public final class Model extends Table {
   public static void addLastIndexId(FlatBufferBuilder builder, int lastIndexIdOffset) { builder.addStruct(5, lastIndexIdOffset, 0); }
   public static void addLastSequenceId(FlatBufferBuilder builder, int lastSequenceIdOffset) { builder.addStruct(6, lastSequenceIdOffset, 0); }
   public static void addLastRelationId(FlatBufferBuilder builder, int lastRelationIdOffset) { builder.addStruct(7, lastRelationIdOffset, 0); }
+  public static void addHash(FlatBufferBuilder builder, int hashOffset) { builder.addOffset(8, hashOffset, 0); }
+  public static int createHashVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+  public static int createHashVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
+  public static void startHashVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
   public static int endModel(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java b/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java
index b2e4e2d1..94418193 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/ModelEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,14 +18,29 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import com.google.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
+/**
+ * The type/class of an entity object.
+ */
 @SuppressWarnings("unused")
 public final class ModelEntity extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ModelEntity getRootAsModelEntity(ByteBuffer _bb) { return getRootAsModelEntity(_bb, new ModelEntity()); }
   public static ModelEntity getRootAsModelEntity(ByteBuffer _bb, ModelEntity obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -58,8 +73,14 @@ public final class ModelEntity extends Table {
   public String nameSecondary() { int o = __offset(16); return o != 0 ? __string(o + bb_pos) : null; }
   public ByteBuffer nameSecondaryAsByteBuffer() { return __vector_as_bytebuffer(16, 1); }
   public ByteBuffer nameSecondaryInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 16, 1); }
+  /**
+   * Optional name used in an external system, e.g. another database that ObjectBox syncs with.
+   */
+  public String externalName() { int o = __offset(18); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer externalNameAsByteBuffer() { return __vector_as_bytebuffer(18, 1); }
+  public ByteBuffer externalNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 18, 1); }
 
-  public static void startModelEntity(FlatBufferBuilder builder) { builder.startTable(7); }
+  public static void startModelEntity(FlatBufferBuilder builder) { builder.startTable(8); }
   public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
   public static void addProperties(FlatBufferBuilder builder, int propertiesOffset) { builder.addOffset(2, propertiesOffset, 0); }
@@ -69,8 +90,9 @@ public final class ModelEntity extends Table {
   public static void addRelations(FlatBufferBuilder builder, int relationsOffset) { builder.addOffset(4, relationsOffset, 0); }
   public static int createRelationsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
   public static void startRelationsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
-  public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(5, (int)flags, (int)0L); }
+  public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(5, (int) flags, (int) 0L); }
   public static void addNameSecondary(FlatBufferBuilder builder, int nameSecondaryOffset) { builder.addOffset(6, nameSecondaryOffset, 0); }
+  public static void addExternalName(FlatBufferBuilder builder, int externalNameOffset) { builder.addOffset(7, externalNameOffset, 0); }
   public static int endModelEntity(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java b/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java
index 64c5edb4..1a3baf56 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/ModelProperty.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,14 +18,26 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import com.google.flatbuffers.*;
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
 @SuppressWarnings("unused")
 public final class ModelProperty extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ModelProperty getRootAsModelProperty(ByteBuffer _bb) { return getRootAsModelProperty(_bb, new ModelProperty()); }
   public static ModelProperty getRootAsModelProperty(ByteBuffer _bb, ModelProperty obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -44,13 +56,20 @@ public final class ModelProperty extends Table {
   public io.objectbox.model.IdUid indexId() { return indexId(new io.objectbox.model.IdUid()); }
   public io.objectbox.model.IdUid indexId(io.objectbox.model.IdUid obj) { int o = __offset(12); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
   /**
-   * For relations only: name of the target entity
+   * For relations only: name of the target entity (will be replaced by "target entity ID" at the schema level)
    */
   public String targetEntity() { int o = __offset(14); return o != 0 ? __string(o + bb_pos) : null; }
   public ByteBuffer targetEntityAsByteBuffer() { return __vector_as_bytebuffer(14, 1); }
   public ByteBuffer targetEntityInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 14, 1); }
   /**
-   * E.g. for virtual to-one target ID properties, this references the ToOne object
+   * This will probably move out of the core model into something binding specific.
+   * A virtual property's "target name" typically references an existing field in the entity at the language level
+   * of the binding. In contrast to this, the virtual property (via model "name") does not exist in the entity at
+   * the language level (thus virtual), but in ObjectBox's core DB.
+   * Example: consider a Java entity which has a ToOne (a Java specific relation wrapper) member called "parent".
+   * ObjectBox core is unaware of that ToOne, but works with the "parentId" relation property,
+   * which in turn does not exist in the Java entity.
+   * The mapping between "parentId" and "parent" is done by our JNI binding.
    */
   public String virtualTarget() { int o = __offset(16); return o != 0 ? __string(o + bb_pos) : null; }
   public ByteBuffer virtualTargetAsByteBuffer() { return __vector_as_bytebuffer(16, 1); }
@@ -65,17 +84,37 @@ public final class ModelProperty extends Table {
    * For value-based indexes, this defines the maximum length of the value stored for indexing
    */
   public long maxIndexValueLength() { int o = __offset(20); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * For float vectors properties and nearest neighbor search, you can index the property with HNSW.
+   * This is the configuration for the HNSW index, e.g. dimensions and parameters affecting quality/speed tradeoff.
+   */
+  public io.objectbox.model.HnswParams hnswParams() { return hnswParams(new io.objectbox.model.HnswParams()); }
+  public io.objectbox.model.HnswParams hnswParams(io.objectbox.model.HnswParams obj) { int o = __offset(22); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+  /**
+   * Optional type used in an external system, e.g. another database that ObjectBox syncs with.
+   * Note that the supported mappings from ObjectBox types to external types are limited.
+   */
+  public int externalType() { int o = __offset(24); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Optional name used in an external system, e.g. another database that ObjectBox syncs with.
+   */
+  public String externalName() { int o = __offset(26); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer externalNameAsByteBuffer() { return __vector_as_bytebuffer(26, 1); }
+  public ByteBuffer externalNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 26, 1); }
 
-  public static void startModelProperty(FlatBufferBuilder builder) { builder.startTable(9); }
+  public static void startModelProperty(FlatBufferBuilder builder) { builder.startTable(12); }
   public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
-  public static void addType(FlatBufferBuilder builder, int type) { builder.addShort(2, (short)type, (short)0); }
-  public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(3, (int)flags, (int)0L); }
+  public static void addType(FlatBufferBuilder builder, int type) { builder.addShort(2, (short) type, (short) 0); }
+  public static void addFlags(FlatBufferBuilder builder, long flags) { builder.addInt(3, (int) flags, (int) 0L); }
   public static void addIndexId(FlatBufferBuilder builder, int indexIdOffset) { builder.addStruct(4, indexIdOffset, 0); }
   public static void addTargetEntity(FlatBufferBuilder builder, int targetEntityOffset) { builder.addOffset(5, targetEntityOffset, 0); }
   public static void addVirtualTarget(FlatBufferBuilder builder, int virtualTargetOffset) { builder.addOffset(6, virtualTargetOffset, 0); }
   public static void addNameSecondary(FlatBufferBuilder builder, int nameSecondaryOffset) { builder.addOffset(7, nameSecondaryOffset, 0); }
-  public static void addMaxIndexValueLength(FlatBufferBuilder builder, long maxIndexValueLength) { builder.addInt(8, (int)maxIndexValueLength, (int)0L); }
+  public static void addMaxIndexValueLength(FlatBufferBuilder builder, long maxIndexValueLength) { builder.addInt(8, (int) maxIndexValueLength, (int) 0L); }
+  public static void addHnswParams(FlatBufferBuilder builder, int hnswParamsOffset) { builder.addOffset(9, hnswParamsOffset, 0); }
+  public static void addExternalType(FlatBufferBuilder builder, int externalType) { builder.addShort(10, (short) externalType, (short) 0); }
+  public static void addExternalName(FlatBufferBuilder builder, int externalNameOffset) { builder.addOffset(11, externalNameOffset, 0); }
   public static int endModelProperty(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java b/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java
index 3c03a82a..581457b8 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/ModelRelation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,14 +18,20 @@
 
 package io.objectbox.model;
 
-import java.nio.*;
-import java.lang.*;
-import java.util.*;
-import com.google.flatbuffers.*;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.Table;
+
+/**
+ * A many-to-many relation between two entity types.
+ */
 @SuppressWarnings("unused")
 public final class ModelRelation extends Table {
-  public static void ValidateVersion() { Constants.FLATBUFFERS_1_12_0(); }
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
   public static ModelRelation getRootAsModelRelation(ByteBuffer _bb) { return getRootAsModelRelation(_bb, new ModelRelation()); }
   public static ModelRelation getRootAsModelRelation(ByteBuffer _bb, ModelRelation obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
   public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
@@ -38,11 +44,25 @@ public final class ModelRelation extends Table {
   public ByteBuffer nameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
   public io.objectbox.model.IdUid targetEntityId() { return targetEntityId(new io.objectbox.model.IdUid()); }
   public io.objectbox.model.IdUid targetEntityId(io.objectbox.model.IdUid obj) { int o = __offset(8); return o != 0 ? obj.__assign(o + bb_pos, bb) : null; }
+  /**
+   * Optional type used in an external system, e.g. another database that ObjectBox syncs with.
+   * Note that the supported mappings from ObjectBox types to external types are limited.
+   * Here, external relation types must be vectors, i.e. a list of IDs.
+   */
+  public int externalType() { int o = __offset(10); return o != 0 ? bb.getShort(o + bb_pos) & 0xFFFF : 0; }
+  /**
+   * Optional name used in an external system, e.g. another database that ObjectBox syncs with.
+   */
+  public String externalName() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer externalNameAsByteBuffer() { return __vector_as_bytebuffer(12, 1); }
+  public ByteBuffer externalNameInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); }
 
-  public static void startModelRelation(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void startModelRelation(FlatBufferBuilder builder) { builder.startTable(5); }
   public static void addId(FlatBufferBuilder builder, int idOffset) { builder.addStruct(0, idOffset, 0); }
   public static void addName(FlatBufferBuilder builder, int nameOffset) { builder.addOffset(1, nameOffset, 0); }
   public static void addTargetEntityId(FlatBufferBuilder builder, int targetEntityIdOffset) { builder.addStruct(2, targetEntityIdOffset, 0); }
+  public static void addExternalType(FlatBufferBuilder builder, int externalType) { builder.addShort(3, (short) externalType, (short) 0); }
+  public static void addExternalName(FlatBufferBuilder builder, int externalNameOffset) { builder.addOffset(4, externalNameOffset, 0); }
   public static int endModelRelation(FlatBufferBuilder builder) {
     int o = builder.endTable();
     return o;
diff --git a/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java b/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java
index ab93b578..17ee468e 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/PropertyFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,6 +22,7 @@
  * Bit-flags defining the behavior of properties.
  * Note: Numbers indicate the bit position
  */
+@SuppressWarnings("unused")
 public final class PropertyFlags {
   private PropertyFlags() { }
   /**
@@ -86,12 +87,45 @@ private PropertyFlags() { }
    */
   public static final int UNSIGNED = 8192;
   /**
-   * By defining an ID companion property, the entity type uses a special ID encoding scheme involving this property
-   * in addition to the ID.
+   * By defining an ID companion property, a special ID encoding scheme is activated involving this property.
    *
    * For Time Series IDs, a companion property of type Date or DateNano represents the exact timestamp.
-   * (Future idea: string hash IDs, with a String companion property to store the full string ID).
+   * (In the future, ID companion string properties may be added as another supported type).
    */
   public static final int ID_COMPANION = 16384;
+  /**
+   * Unique on-conflict strategy: the object being put replaces any existing conflicting object (deletes it).
+   */
+  public static final int UNIQUE_ON_CONFLICT_REPLACE = 32768;
+  /**
+   * If a date property has this flag (max. one per entity type), the date value specifies the time by which
+   * the object expires, at which point it MAY be deleted. There's no strict guarantee when the deletion happens.
+   * However, the deletion process can be triggered by an API call.
+   */
+  public static final int EXPIRATION_TIME = 65536;
+  /**
+   * Marks a Long (64-bit integer) property as a the sync clock, a "hybrid logical clock" to resolve Sync conflicts.
+   * These clock values allow "last write wins" conflict resolution.
+   * There can be only one sync clock per sync entity type; which is also recommended for basic conflict resolution.
+   * For new objects, initialize a property value to 0 to reserve "a slot" in the object data.
+   * ObjectBox Sync will update this property automatically on put operations.
+   * As a hybrid clock, it combines a wall clock with a logical counter to compensate for some clock skew effects.
+   */
+  public static final int SYNC_CLOCK = 131072;
+  /**
+   * Marks a Long (64-bit integer) property as a the "sync precedence" to customize Sync conflict resolution.
+   * Developer-assigned precedence values are then used to resolve conflicts via "higher precedence wins".
+   * Defining and assigning precedence values are completely in the hands of the developer (the ObjectBox user).
+   * There can be only one sync precedence per sync entity type.
+   * Typically, it is combined with a sync clock, with the latter being the tie-breaker for equal precedence values.
+   * This can be used to model some business logic use cases, for example:
+   *   - Setting an object a special state, e.g. a final/closed state, which may not be overwritten by a lesser state
+   *   - Multiple workflow states that occur linearly (i.e. using an increasing precedence value)
+   *   - Role based, e.g. only admins set or increment the precedence..
+   *   - “Checkpoint timestamps:” e.g. when some changes are “checked” as in approved/applied,
+   *     the precedence is updated to the current timestamp.
+   *     “Non-checked” or previously checkpointed changes are disregarded.
+   */
+  public static final int SYNC_PRECEDENCE = 262144;
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java b/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java
index 1b1ffc1c..4fb0db94 100644
--- a/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java
+++ b/objectbox-java/src/main/java/io/objectbox/model/PropertyType.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,23 +21,51 @@
 /**
  * Basic type of a property
  */
+@SuppressWarnings("unused")
 public final class PropertyType {
   private PropertyType() { }
   /**
    * Not a real type, just best practice (e.g. forward compatibility)
    */
   public static final short Unknown = 0;
+  /**
+   * A boolean (flag)
+   */
   public static final short Bool = 1;
+  /**
+   * 8-bit integer
+   */
   public static final short Byte = 2;
+  /**
+   * 16-bit integer
+   */
   public static final short Short = 3;
+  /**
+   * 16-bit character
+   */
   public static final short Char = 4;
+  /**
+   * 32-bit integer
+   */
   public static final short Int = 5;
+  /**
+   * 64-bit integer
+   */
   public static final short Long = 6;
+  /**
+   * 32-bit floating point number
+   */
   public static final short Float = 7;
+  /**
+   * 64-bit floating point number
+   */
   public static final short Double = 8;
+  /**
+   * UTF-8 encoded string (variable length)
+   */
   public static final short String = 9;
   /**
-   * Date/time stored as a 64 bit long representing milliseconds since 1970-01-01 (unix epoch)
+   * Date/time stored as a 64-bit (integer) timestamp representing milliseconds since 1970-01-01 (unix epoch)
    */
   public static final short Date = 10;
   /**
@@ -45,10 +73,14 @@ private PropertyType() { }
    */
   public static final short Relation = 11;
   /**
-   * High precision date/time stored as a 64 bit long representing nanoseconds since 1970-01-01 (unix epoch)
+   * High precision date/time stored as a 64-bit timestamp representing nanoseconds since 1970-01-01 (unix epoch)
    */
   public static final short DateNano = 12;
-  public static final short Reserved2 = 13;
+  /**
+   * "Flexible" type, which may contain scalars (integers, floating points), strings or containers (lists and maps).
+   * Note: a flex map must use string keys.
+   */
+  public static final short Flex = 13;
   public static final short Reserved3 = 14;
   public static final short Reserved4 = 15;
   public static final short Reserved5 = 16;
@@ -57,20 +89,52 @@ private PropertyType() { }
   public static final short Reserved8 = 19;
   public static final short Reserved9 = 20;
   public static final short Reserved10 = 21;
+  /**
+   * Variable sized vector of Bool values (boolean; note: each value is represented as one byte)
+   */
   public static final short BoolVector = 22;
+  /**
+   * Variable sized vector of Byte values (8-bit integers)
+   */
   public static final short ByteVector = 23;
+  /**
+   * Variable sized vector of Short values (16-bit integers)
+   */
   public static final short ShortVector = 24;
+  /**
+   * Variable sized vector of Char values (16-bit characters)
+   */
   public static final short CharVector = 25;
+  /**
+   * Variable sized vector of Int values (32-bit integers)
+   */
   public static final short IntVector = 26;
+  /**
+   * Variable sized vector of Long values (64-bit integers)
+   */
   public static final short LongVector = 27;
+  /**
+   * Variable sized vector of Float values (32-bit floating point numbers)
+   */
   public static final short FloatVector = 28;
+  /**
+   * Variable sized vector of Double values (64-bit floating point numbers)
+   */
   public static final short DoubleVector = 29;
+  /**
+   * Variable sized vector of String values (UTF-8 encoded strings).
+   */
   public static final short StringVector = 30;
+  /**
+   * Variable sized vector of Date values (64-bit timestamp).
+   */
   public static final short DateVector = 31;
+  /**
+   * Variable sized vector of Date values (high precision 64-bit timestamp).
+   */
   public static final short DateNanoVector = 32;
 
-  // Private to protect contents from getting modified.
-  private static final String[] names = { "Unknown", "Bool", "Byte", "Short", "Char", "Int", "Long", "Float", "Double", "String", "Date", "Relation", "DateNano", "Reserved2", "Reserved3", "Reserved4", "Reserved5", "Reserved6", "Reserved7", "Reserved8", "Reserved9", "Reserved10", "BoolVector", "ByteVector", "ShortVector", "CharVector", "IntVector", "LongVector", "FloatVector", "DoubleVector", "StringVector", "DateVector", "DateNanoVector", };
+  public static final String[] names = { "Unknown", "Bool", "Byte", "Short", "Char", "Int", "Long", "Float", "Double", "String", "Date", "Relation", "DateNano", "Flex", "Reserved3", "Reserved4", "Reserved5", "Reserved6", "Reserved7", "Reserved8", "Reserved9", "Reserved10", "BoolVector", "ByteVector", "ShortVector", "CharVector", "IntVector", "LongVector", "FloatVector", "DoubleVector", "StringVector", "DateVector", "DateNanoVector", };
 
   public static String name(int e) { return names[e]; }
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/package-info.java b/objectbox-java/src/main/java/io/objectbox/package-info.java
index 4e084547..2db20b8b 100644
--- a/objectbox-java/src/main/java/io/objectbox/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,7 +22,7 @@
  * <li>MyObjectBox: Generated by the Gradle plugin, supplies a {@link io.objectbox.BoxStoreBuilder}
  * to build a BoxStore for your app.</li>
  * <li>{@link io.objectbox.BoxStore}: The database interface, allows to manage Boxes.</li>
- * <li>{@link io.objectbox.Box}: Persists and queries for entities, there is one for each entity.</li>
+ * <li>{@link io.objectbox.Box}: Persists and queries for Objects, there is one for each Entity class.</li>
  * </ul>
  * <p>
  * For more details look at the documentation of individual classes and
diff --git a/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java b/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java
index 343bc795..271a4c98 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/BreakForEach.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java b/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java
index 63ad47ba..32d0667e 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/EagerRelation.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/IdWithScore.java b/objectbox-java/src/main/java/io/objectbox/query/IdWithScore.java
new file mode 100644
index 00000000..d26f2f01
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/IdWithScore.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+/**
+ * Wraps the ID of a matching object and a score when using {@link Query#findIdsWithScores}.
+ */
+public class IdWithScore {
+
+    private final long id;
+    private final double score;
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public IdWithScore(long id, double score) {
+        this.id = id;
+        this.score = score;
+    }
+
+    /**
+     * Returns the object ID.
+     */
+    public long getId() {
+        return id;
+    }
+
+    /**
+     * Returns the query score for the {@link #getId() id}.
+     * <p>
+     * The query score indicates some quality measurement. E.g. for vector nearest neighbor searches, the score is the
+     * distance to the given vector.
+     */
+    public double getScore() {
+        return score;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java b/objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java
new file mode 100644
index 00000000..3546144b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/InternalAccess.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Exposes internal APIs to tests and code in other packages.
+ */
+@Internal
+public class InternalAccess {
+
+    @Internal
+    public static <T> void nativeFindFirst(Query<T> query, long cursorHandle) {
+        query.nativeFindFirst(query.handle, cursorHandle);
+    }
+
+    /**
+     * See {@link QueryPublisher#LOG_STATES}.
+     */
+    @Internal
+    public static void queryPublisherLogStates() {
+        QueryPublisher.LOG_STATES = true;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/LazyList.java b/objectbox-java/src/main/java/io/objectbox/query/LazyList.java
index c1ba765e..8c3a18b2 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/LazyList.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/LazyList.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -22,24 +22,33 @@
 import java.util.ListIterator;
 import java.util.NoSuchElementException;
 
+import javax.annotation.Nullable;
+
 import io.objectbox.Box;
 import io.objectbox.exception.DbException;
 
 /**
- * A thread-safe, unmodifiable list that reads entities lazily once they are accessed.
- * A lazy list can be cached or not.
- * Cached lazy lists store the previously accessed objects to avoid loading entities more than once.
- * Some features of the list are limited to cached lists (e.g. features that require the entire list).
+ * A thread-safe, unmodifiable {@link List} that gets Objects from their Box not until they are accessed.
+ * Internally the list is backed by an array of Object IDs.
+ * <p>
+ * If the list is set to not cache retrieved Objects, each operation will get the latest version of an Object
+ * from its Box. However, in this mode only a limited set of {@link List} operations,
+ * like get or iterator are supported.
+ * <p>
+ * If the list is set to cache retrieved Objects, operations will return a previously fetched version of an Object,
+ * which might not equal the latest version in its Box. However, in this mode almost all {@link List}
+ * operations are supported. Note that operations that require the whole list, like contains, will fetch all
+ * Objects in this list from the Box at once.
  * <p>
- * Note: this list gives an semiconsitent view on the data at the moment it was created.
- * If you remove objects from their object box after this list was created, this list will null instead of an object.
- * However, if you add objects to their object box after this list was created, this list will not be extended.
+ * Note: as Objects are fetched on demand, this list returns a null Object if the Object was removed from its Box
+ * after this list was created.
  *
  * @param <E> Object type (entity).
- * @author Markus
  */
-// Threading note: locking is tailored to ArrayList assuming that concurrent positional gets/sets are OK.
-// To enable this, the internal ArrayList is prepopulated with null.
+/*
+ Threading note: locking is tailored to ArrayList assuming that concurrent positional gets/sets are OK.
+ To enable this, the internal ArrayList is prepopulated with null.
+*/
 public class LazyList<E> implements List<E> {
     protected class LazyIterator implements ListIterator<E> {
         private int index;
@@ -206,9 +215,11 @@ public boolean containsAll(Collection<?> collection) {
     }
 
     /**
-     * @return An object for the given ID, or null if the object was already removed from its box
-     * (and was not cached before).
+     * Gets and returns the Object at the specified position in this list from its Box. Returns null if the
+     * Object was removed from its Box. If this list is caching retrieved Objects, returns the previously
+     * fetched version.
      */
+    @Nullable
     @Override
     public E get(int location) {
         if (location < 0 || location > size) {
@@ -267,6 +278,9 @@ public ListIterator<E> listIterator() {
 
     @Override
     public ListIterator<E> listIterator(int location) {
+        if (location < 0 || location > size) {
+            throw new IndexOutOfBoundsException("Index: " + location + ", Size: " + size);
+        }
         return new LazyIterator(location);
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java b/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java
new file mode 100644
index 00000000..c62b0c9d
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/LogicQueryCondition.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+/**
+ * Logic based query conditions, currently {@link AndCondition} and {@link OrCondition}.
+ */
+abstract class LogicQueryCondition<T> extends QueryConditionImpl<T> {
+
+    private final QueryConditionImpl<T> leftCondition;
+    private final QueryConditionImpl<T> rightCondition;
+
+    LogicQueryCondition(QueryConditionImpl<T> leftCondition, QueryConditionImpl<T> rightCondition) {
+        this.leftCondition = leftCondition;
+        this.rightCondition = rightCondition;
+    }
+
+    @Override
+    void apply(QueryBuilder<T> builder) {
+        leftCondition.apply(builder);
+        long leftConditionPointer = builder.internalGetLastCondition();
+
+        rightCondition.apply(builder);
+        long rightConditionPointer = builder.internalGetLastCondition();
+
+        applyOperator(builder, leftConditionPointer, rightConditionPointer);
+    }
+
+    abstract void applyOperator(QueryBuilder<T> builder, long leftCondition, long rightCondition);
+
+    /**
+     * Combines the left condition using AND with the right condition.
+     */
+    static class AndCondition<T> extends LogicQueryCondition<T> {
+
+        AndCondition(QueryConditionImpl<T> leftCondition, QueryConditionImpl<T> rightCondition) {
+            super(leftCondition, rightCondition);
+        }
+
+        @Override
+        void applyOperator(QueryBuilder<T> builder, long leftCondition, long rightCondition) {
+            builder.internalAnd(leftCondition, rightCondition);
+        }
+    }
+
+    /**
+     * Combines the left condition using OR with the right condition.
+     */
+    static class OrCondition<T> extends LogicQueryCondition<T> {
+
+        OrCondition(QueryConditionImpl<T> leftCondition, QueryConditionImpl<T> rightCondition) {
+            super(leftCondition, rightCondition);
+        }
+
+        @Override
+        void applyOperator(QueryBuilder<T> builder, long leftCondition, long rightCondition) {
+            builder.internalOr(leftCondition, rightCondition);
+        }
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/ObjectWithScore.java b/objectbox-java/src/main/java/io/objectbox/query/ObjectWithScore.java
new file mode 100644
index 00000000..38e3f75f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/ObjectWithScore.java
@@ -0,0 +1,50 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+/**
+ * Wraps a matching object and a score when using {@link Query#findWithScores}.
+ */
+public class ObjectWithScore<T> {
+
+    private final T object;
+    private final double score;
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public ObjectWithScore(T object, double score) {
+        this.object = object;
+        this.score = score;
+    }
+
+    // Do not use getObject() to avoid having to escape the name in Kotlin
+    /**
+     * Returns the matching object.
+     */
+    public T get() {
+        return object;
+    }
+
+    /**
+     * Returns the query score for the {@link #get() object}.
+     * <p>
+     * The query score indicates some quality measurement. E.g. for vector nearest neighbor searches, the score is the
+     * distance to the given vector.
+     */
+    public double getScore() {
+        return score;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java b/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java
index 1d8fc38d..96b451cf 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/OrderFlags.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,6 +21,7 @@
 /**
  * Not really an enum, but binary flags to use across languages
  */
+@SuppressWarnings("unused")
 public final class OrderFlags {
   private OrderFlags() { }
   /**
@@ -45,10 +46,5 @@ private OrderFlags() { }
    * null values should be treated equal to zero (scalars only).
    */
   public static final int NULLS_ZERO = 16;
-
-  // Private to protect contents from getting modified.
-  private static final String[] names = { "DESCENDING", "CASE_SENSITIVE", "", "UNSIGNED", "", "", "", "NULLS_LAST", "", "", "", "", "", "", "", "NULLS_ZERO", };
-
-  public static String name(int e) { return names[e - DESCENDING]; }
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java b/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java
index 9ddc5100..c54e879d 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/PropertyQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -347,10 +347,10 @@ public Double findDouble() {
 
     /**
      * Sums up all values for the given property over all Objects matching the query.
-     *
+     * <p>
      * Note: this method is not recommended for properties of type long unless you know the contents of the DB not to
-     *       overflow. Use {@link #sumDouble()} instead if you cannot guarantee the sum to be in the long value range.
-     * 
+     * overflow. Use {@link #sumDouble()} instead if you cannot guarantee the sum to be in the long value range.
+     *
      * @return 0 in case no elements matched the query
      * @throws io.objectbox.exception.NumericOverflowException if the sum exceeds the numbers {@link Long} can
      * represent.
@@ -362,11 +362,11 @@ public long sum() {
         );
     }
 
-    /** 
+    /**
      * Sums up all values for the given property over all Objects matching the query.
-     * 
+     * <p>
      * Note: for integer types int and smaller, {@link #sum()} is usually preferred for sums.
-     *       
+     *
      * @return 0 in case no elements matched the query
      */
     public double sumDouble() {
@@ -386,9 +386,9 @@ public long max() {
         );
     }
 
-    /** 
+    /**
      * Finds the maximum value for the given property over all Objects matching the query.
-     * 
+     *
      * @return NaN in case no elements matched the query
      */
     public double maxDouble() {
diff --git a/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java
new file mode 100644
index 00000000..b1f7cbb9
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryCondition.java
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.Property;
+
+/**
+ * A condition on a {@link Property}, which can have an alias to allow referring to it later.
+ */
+public interface PropertyQueryCondition<T> extends QueryCondition<T> {
+
+    /**
+     * Assigns an alias to this condition that can later be used with the {@link Query} setParameter methods.
+     */
+    QueryCondition<T> alias(String name);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java
new file mode 100644
index 00000000..0bf40400
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/PropertyQueryConditionImpl.java
@@ -0,0 +1,578 @@
+/*
+ * Copyright 2020-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import java.util.Date;
+
+import io.objectbox.Property;
+import io.objectbox.query.QueryBuilder.StringOrder;
+
+/**
+ * {@link Property} based query conditions with implementations split by number and type of values,
+ * such as {@link LongCondition LongCondition}, {@link LongLongCondition LongLongCondition},
+ * {@link LongArrayCondition LongArrayCondition} and the general {@link NullCondition NullCondition}.
+ * <p>
+ * Each condition implementation has a set of operation enums, e.g. EQUAL/NOT_EQUAL/..., which represent the actual
+ * query condition passed to the native query builder.
+ */
+public abstract class PropertyQueryConditionImpl<T> extends QueryConditionImpl<T> implements PropertyQueryCondition<T> {
+    // Note: Expose for DAOcompat
+    public final Property<T> property;
+    private String alias;
+
+    PropertyQueryConditionImpl(Property<T> property) {
+        this.property = property;
+    }
+
+    @Override
+    public QueryCondition<T> alias(String name) {
+        this.alias = name;
+        return this;
+    }
+
+    // Note: Expose for DAOcompat
+    @Override
+    public void apply(QueryBuilder<T> builder) {
+        applyCondition(builder);
+        if (alias != null && alias.length() != 0) {
+            builder.parameterAlias(alias);
+        }
+    }
+
+    abstract void applyCondition(QueryBuilder<T> builder);
+
+    public static class NullCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+
+        public enum Operation {
+            IS_NULL,
+            NOT_NULL
+        }
+
+        public NullCondition(Property<T> property, Operation op) {
+            super(property);
+            this.op = op;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case IS_NULL:
+                    builder.isNull(property);
+                    break;
+                case NOT_NULL:
+                    builder.notNull(property);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported");
+            }
+        }
+    }
+
+    public static class IntArrayCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final int[] value;
+
+        public enum Operation {
+            IN,
+            NOT_IN
+        }
+
+        public IntArrayCondition(Property<T> property, Operation op, int[] value) {
+            super(property);
+            this.op = op;
+            this.value = value;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case IN:
+                    builder.in(property, value);
+                    break;
+                case NOT_IN:
+                    builder.notIn(property, value);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported for int[]");
+            }
+        }
+    }
+
+    public static class LongCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final long value;
+
+        public enum Operation {
+            EQUAL,
+            NOT_EQUAL,
+            GREATER,
+            GREATER_OR_EQUAL,
+            LESS,
+            LESS_OR_EQUAL
+        }
+
+        public LongCondition(Property<T> property, Operation op, long value) {
+            super(property);
+            this.op = op;
+            this.value = value;
+        }
+
+        public LongCondition(Property<T> property, Operation op, boolean value) {
+            this(property, op, value ? 1 : 0);
+        }
+
+        public LongCondition(Property<T> property, Operation op, Date value) {
+            this(property, op, value.getTime());
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case EQUAL:
+                    builder.equal(property, value);
+                    break;
+                case NOT_EQUAL:
+                    builder.notEqual(property, value);
+                    break;
+                case GREATER:
+                    builder.greater(property, value);
+                    break;
+                case GREATER_OR_EQUAL:
+                    builder.greaterOrEqual(property, value);
+                    break;
+                case LESS:
+                    builder.less(property, value);
+                    break;
+                case LESS_OR_EQUAL:
+                    builder.lessOrEqual(property, value);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported for String");
+            }
+        }
+    }
+
+    public static class LongLongCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final long leftValue;
+        private final long rightValue;
+
+        public enum Operation {
+            BETWEEN
+        }
+
+        public LongLongCondition(Property<T> property, Operation op, long leftValue, long rightValue) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+        }
+
+        public LongLongCondition(Property<T> property, Operation op, Date leftValue, Date rightValue) {
+            this(property, op, leftValue.getTime(), rightValue.getTime());
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.BETWEEN) {
+                builder.between(property, leftValue, rightValue);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two long values");
+            }
+        }
+    }
+
+    public static class LongArrayCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final long[] value;
+
+        public enum Operation {
+            IN,
+            NOT_IN
+        }
+
+        public LongArrayCondition(Property<T> property, Operation op, long[] value) {
+            super(property);
+            this.op = op;
+            this.value = value;
+        }
+
+        public LongArrayCondition(Property<T> property, Operation op, Date[] value) {
+            super(property);
+            this.op = op;
+            this.value = new long[value.length];
+            for (int i = 0; i < value.length; i++) {
+                this.value[i] = value[i].getTime();
+            }
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case IN:
+                    builder.in(property, value);
+                    break;
+                case NOT_IN:
+                    builder.notIn(property, value);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported for long[]");
+            }
+        }
+    }
+
+    public static class DoubleCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final double value;
+
+        public enum Operation {
+            GREATER,
+            GREATER_OR_EQUAL,
+            LESS,
+            LESS_OR_EQUAL
+        }
+
+        public DoubleCondition(Property<T> property, Operation op, double value) {
+            super(property);
+            this.op = op;
+            this.value = value;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case GREATER:
+                    builder.greater(property, value);
+                    break;
+                case GREATER_OR_EQUAL:
+                    builder.greaterOrEqual(property, value);
+                    break;
+                case LESS:
+                    builder.less(property, value);
+                    break;
+                case LESS_OR_EQUAL:
+                    builder.lessOrEqual(property, value);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported for double");
+            }
+        }
+    }
+
+    public static class DoubleDoubleCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final double leftValue;
+        private final double rightValue;
+
+        public enum Operation {
+            BETWEEN
+        }
+
+        public DoubleDoubleCondition(Property<T> property, Operation op, double leftValue, double rightValue) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.BETWEEN) {
+                builder.between(property, leftValue, rightValue);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two double values");
+            }
+        }
+    }
+
+    public static class StringCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String value;
+        private final StringOrder order;
+
+        public enum Operation {
+            EQUAL,
+            NOT_EQUAL,
+            GREATER,
+            GREATER_OR_EQUAL,
+            LESS,
+            LESS_OR_EQUAL,
+            CONTAINS,
+            CONTAINS_ELEMENT,
+            STARTS_WITH,
+            ENDS_WITH
+        }
+
+        public StringCondition(Property<T> property, Operation op, String value, StringOrder order) {
+            super(property);
+            this.op = op;
+            this.value = value;
+            this.order = order;
+        }
+
+        public StringCondition(Property<T> property, Operation op, String value) {
+            this(property, op, value, StringOrder.CASE_SENSITIVE);
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case EQUAL:
+                    builder.equal(property, value, order);
+                    break;
+                case NOT_EQUAL:
+                    builder.notEqual(property, value, order);
+                    break;
+                case GREATER:
+                    builder.greater(property, value, order);
+                    break;
+                case GREATER_OR_EQUAL:
+                    builder.greaterOrEqual(property, value, order);
+                    break;
+                case LESS:
+                    builder.less(property, value, order);
+                    break;
+                case LESS_OR_EQUAL:
+                    builder.lessOrEqual(property, value, order);
+                    break;
+                case CONTAINS:
+                    builder.contains(property, value, order);
+                    break;
+                case CONTAINS_ELEMENT:
+                    builder.containsElement(property, value, order);
+                    break;
+                case STARTS_WITH:
+                    builder.startsWith(property, value, order);
+                    break;
+                case ENDS_WITH:
+                    builder.endsWith(property, value, order);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported for String");
+            }
+        }
+    }
+
+    public static class StringStringCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String leftValue;
+        private final String rightValue;
+        private final StringOrder order;
+
+        public enum Operation {
+            EQUAL_KEY_VALUE,
+            GREATER_KEY_VALUE,
+            GREATER_EQUALS_KEY_VALUE,
+            LESS_KEY_VALUE,
+            LESS_EQUALS_KEY_VALUE
+        }
+
+        public StringStringCondition(Property<T> property, Operation op, String leftValue, String rightValue, StringOrder order) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+            this.order = order;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.EQUAL_KEY_VALUE) {
+                builder.equalKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.GREATER_KEY_VALUE) {
+                builder.greaterKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.GREATER_EQUALS_KEY_VALUE) {
+                builder.greaterOrEqualKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.LESS_KEY_VALUE) {
+                builder.lessKeyValue(property, leftValue, rightValue, order);
+            } else if (op == Operation.LESS_EQUALS_KEY_VALUE) {
+                builder.lessOrEqualKeyValue(property, leftValue, rightValue, order);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two String values");
+            }
+        }
+    }
+
+    public static class StringLongCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String leftValue;
+        private final long rightValue;
+
+        public enum Operation {
+            EQUAL_KEY_VALUE,
+            GREATER_KEY_VALUE,
+            GREATER_EQUALS_KEY_VALUE,
+            LESS_KEY_VALUE,
+            LESS_EQUALS_KEY_VALUE
+        }
+
+        public StringLongCondition(Property<T> property, Operation op, String leftValue, long rightValue) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.EQUAL_KEY_VALUE) {
+                builder.equalKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_KEY_VALUE) {
+                builder.greaterKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_EQUALS_KEY_VALUE) {
+                builder.greaterOrEqualKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_KEY_VALUE) {
+                builder.lessKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_EQUALS_KEY_VALUE) {
+                builder.lessOrEqualKeyValue(property, leftValue, rightValue);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two String values");
+            }
+        }
+    }
+
+    public static class StringDoubleCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String leftValue;
+        private final double rightValue;
+
+        public enum Operation {
+            EQUAL_KEY_VALUE,
+            GREATER_KEY_VALUE,
+            GREATER_EQUALS_KEY_VALUE,
+            LESS_KEY_VALUE,
+            LESS_EQUALS_KEY_VALUE
+        }
+
+        public StringDoubleCondition(Property<T> property, Operation op, String leftValue, double rightValue) {
+            super(property);
+            this.op = op;
+            this.leftValue = leftValue;
+            this.rightValue = rightValue;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.EQUAL_KEY_VALUE) {
+                builder.equalKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_KEY_VALUE) {
+                builder.greaterKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.GREATER_EQUALS_KEY_VALUE) {
+                builder.greaterOrEqualKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_KEY_VALUE) {
+                builder.lessKeyValue(property, leftValue, rightValue);
+            } else if (op == Operation.LESS_EQUALS_KEY_VALUE) {
+                builder.lessOrEqualKeyValue(property, leftValue, rightValue);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported with two String values");
+            }
+        }
+    }
+
+    public static class StringArrayCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final String[] value;
+        private final StringOrder order;
+
+        public enum Operation {
+            IN
+        }
+
+        public StringArrayCondition(Property<T> property, Operation op, String[] value, StringOrder order) {
+            super(property);
+            this.op = op;
+            this.value = value;
+            this.order = order;
+        }
+
+        public StringArrayCondition(Property<T> property, Operation op, String[] value) {
+            this(property, op, value, StringOrder.CASE_SENSITIVE);
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            if (op == Operation.IN) {
+                builder.in(property, value, order);
+            } else {
+                throw new UnsupportedOperationException(op + " is not supported for String[]");
+            }
+        }
+    }
+
+    public static class ByteArrayCondition<T> extends PropertyQueryConditionImpl<T> {
+        private final Operation op;
+        private final byte[] value;
+
+        public enum Operation {
+            EQUAL,
+            GREATER,
+            GREATER_OR_EQUAL,
+            LESS,
+            LESS_OR_EQUAL
+        }
+
+        public ByteArrayCondition(Property<T> property, Operation op, byte[] value) {
+            super(property);
+            this.op = op;
+            this.value = value;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            switch (op) {
+                case EQUAL:
+                    builder.equal(property, value);
+                    break;
+                case GREATER:
+                    builder.greater(property, value);
+                    break;
+                case GREATER_OR_EQUAL:
+                    builder.greaterOrEqual(property, value);
+                    break;
+                case LESS:
+                    builder.less(property, value);
+                    break;
+                case LESS_OR_EQUAL:
+                    builder.lessOrEqual(property, value);
+                    break;
+                default:
+                    throw new UnsupportedOperationException(op + " is not supported for byte[]");
+            }
+        }
+    }
+
+    /**
+     * Conditions for properties with an {@link io.objectbox.annotation.HnswIndex}.
+     */
+    public static class NearestNeighborCondition<T> extends PropertyQueryConditionImpl<T> {
+
+        private final float[] queryVector;
+        private final int maxResultCount;
+
+        public NearestNeighborCondition(Property<T> property, float[] queryVector, int maxResultCount) {
+            super(property);
+            this.queryVector = queryVector;
+            this.maxResultCount = maxResultCount;
+        }
+
+        @Override
+        void applyCondition(QueryBuilder<T> builder) {
+            builder.nearestNeighbors(property, queryVector, maxResultCount);
+        }
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/Query.java b/objectbox-java/src/main/java/io/objectbox/query/Query.java
index ee2d9df5..4c4f5c07 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/Query.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/Query.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2020 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -31,6 +31,9 @@
 import io.objectbox.BoxStore;
 import io.objectbox.InternalAccess;
 import io.objectbox.Property;
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.HnswIndex;
+import io.objectbox.exception.NonUniqueResultException;
 import io.objectbox.reactive.DataObserver;
 import io.objectbox.reactive.DataSubscriptionList;
 import io.objectbox.reactive.SubscriptionBuilder;
@@ -38,25 +41,42 @@
 import io.objectbox.relation.ToOne;
 
 /**
- * A repeatable query returning entities.
+ * A repeatable Query returning the latest matching objects.
+ * <p>
+ * Use {@link #find()} or related methods to fetch the latest results from the {@link BoxStore}.
+ * <p>
+ * Use {@link #property(Property)} to only return values or an aggregate of a single Property.
+ * <p>
+ * Make sure to {@link #close()} this query once done with it to reclaim resources immediately.
+ * <p>
+ * See the <a href="https://docs.objectbox.io/queries">Queries documentation</a> for details.
  *
- * @param <T> The entity class the query will return results for.
- * @author Markus
- * @see QueryBuilder
+ * @param <T> Entity class for which results are returned.
  */
 @SuppressWarnings({"SameParameterValue", "UnusedReturnValue", "WeakerAccess"})
 public class Query<T> implements Closeable {
 
     native void nativeDestroy(long handle);
 
+    /** Clones the native query, incl. conditions and parameters, and returns a handle to the clone. */
+    native long nativeClone(long handle);
+
     native Object nativeFindFirst(long handle, long cursorHandle);
 
     native Object nativeFindUnique(long handle, long cursorHandle);
 
     native List<T> nativeFind(long handle, long cursorHandle, long offset, long limit) throws Exception;
 
+    native long nativeFindFirstId(long handle, long cursorHandle);
+
+    native long nativeFindUniqueId(long handle, long cursorHandle);
+
     native long[] nativeFindIds(long handle, long cursorHandle, long offset, long limit);
 
+    native List<ObjectWithScore<T>> nativeFindWithScores(long handle, long cursorHandle, long offset, long limit);
+
+    native List<IdWithScore> nativeFindIdsWithScores(long handle, long cursorHandle, long offset, long limit);
+
     native long nativeCount(long handle, long cursorHandle);
 
     native long nativeRemove(long handle, long cursorHandle);
@@ -68,6 +88,9 @@ public class Query<T> implements Closeable {
     native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
                                    String value);
 
+    private native void nativeSetParameters(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
+                                            String value, String value2);
+
     native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
                                    long value);
 
@@ -92,6 +115,9 @@ native void nativeSetParameters(long handle, int entityId, int propertyId, @Null
     native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
                                    byte[] value);
 
+    native void nativeSetParameter(long handle, int entityId, int propertyId, @Nullable String parameterAlias,
+                                    float[] values);
+
     final Box<T> box;
     private final BoxStore store;
     private final QueryPublisher<T> publisher;
@@ -101,9 +127,10 @@ native void nativeSetParameter(long handle, int entityId, int propertyId, @Nulla
     private final int queryAttempts;
     private static final int INITIAL_RETRY_BACK_OFF_IN_MS = 10;
 
-    long handle;
+    // volatile so checkOpen() is more up-to-date (no need for synchronized; it's a race anyway)
+    volatile long handle;
 
-    Query(Box<T> box, long queryHandle, @Nullable List<EagerRelation<T, ?>> eagerRelations, @Nullable  QueryFilter<T> filter,
+    Query(Box<T> box, long queryHandle, @Nullable List<EagerRelation<T, ?>> eagerRelations, @Nullable QueryFilter<T> filter,
           @Nullable Comparator<T> comparator) {
         this.box = box;
         store = box.getStore();
@@ -115,6 +142,20 @@ native void nativeSetParameter(long handle, int entityId, int propertyId, @Nulla
         this.comparator = comparator;
     }
 
+    /**
+     * Creates a copy of the {@code originalQuery}, but pointing to a different native query using {@code handle}.
+     */
+    // Note: not using recommended copy constructor (just passing this) as handle needs to change.
+    private Query(Query<T> originalQuery, long handle) {
+        this(
+                originalQuery.box,
+                handle,
+                originalQuery.eagerRelations,
+                originalQuery.filter,
+                originalQuery.comparator
+        );
+    }
+
     /**
      * Explicitly call {@link #close()} instead to avoid expensive finalization.
      */
@@ -126,9 +167,15 @@ protected void finalize() throws Throwable {
     }
 
     /**
-     * If possible, try to close the query once you are done with it to reclaim resources immediately.
+     * Closes this query and frees used resources.
+     * <p>
+     * If possible, call this always once done with this. Otherwise, will be called once this is finalized (e.g. garbage
+     * collected).
+     * <p>
+     * Calling any other methods of this afterwards will throw an {@link IllegalStateException}.
      */
     public synchronized void close() {
+        publisher.stopAndAwait();  // Ensure it is done so that the query is not used anymore
         if (handle != 0) {
             // Closeable recommendation: mark as "closed" before nativeDestroy could throw.
             long handleCopy = handle;
@@ -137,13 +184,34 @@ public synchronized void close() {
         }
     }
 
+    /**
+     * Creates a copy of this for use in another thread.
+     * <p>
+     * Clones the native query, keeping any previously set parameters.
+     * <p>
+     * Closing the original query does not close the copy. {@link #close()} the copy once finished using it.
+     * <p>
+     * Note: a set {@link QueryBuilder#filter(QueryFilter) filter} or {@link QueryBuilder#sort(Comparator) sort}
+     * order <b>must be thread safe</b>.
+     */
+    // Note: not overriding clone() to avoid confusion with Java's cloning mechanism.
+    public Query<T> copy() {
+        long cloneHandle = nativeClone(handle);
+        return new Query<>(this, cloneHandle);
+    }
+
     /** To be called inside a read TX */
     long cursorHandle() {
         return InternalAccess.getActiveTxCursorHandle(box);
     }
 
     /**
-     * Find the first Object matching the query.
+     * Finds the first object matching this query.
+     * <p>
+     * Note: if no {@link QueryBuilder#order} conditions are present, which object is the first one might be arbitrary
+     * (sometimes the one with the lowest ID, but never guaranteed to be).
+     *
+     * @return The first object if there are matches. {@code null} if no object matches.
      */
     @Nullable
     public T findFirst() {
@@ -176,9 +244,10 @@ private void ensureNoComparator() {
     }
 
     /**
-     * Find the unique Object matching the query.
+     * Finds the only object matching this query.
      *
-     * @throws io.objectbox.exception.NonUniqueResultException if result was not unique
+     * @return The object if a single object matches. {@code null} if no object matches. Throws
+     * {@link NonUniqueResultException} if there are multiple objects matching the query.
      */
     @Nullable
     public T findUnique() {
@@ -192,7 +261,12 @@ public T findUnique() {
     }
 
     /**
-     * Find all Objects matching the query.
+     * Finds objects matching the query.
+     * <p>
+     * Note: if no {@link QueryBuilder#order} conditions are present, the order is arbitrary (sometimes ordered by ID,
+     * but never guaranteed to).
+     *
+     * @return A list of matching objects. An empty list if no object matches.
      */
     @Nonnull
     public List<T> find() {
@@ -216,7 +290,12 @@ public List<T> find() {
     }
 
     /**
-     * Find all Objects matching the query between the given offset and limit. This helps with pagination.
+     * Like {@link #find()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
      */
     @Nonnull
     public List<T> find(final long offset, final long limit) {
@@ -229,35 +308,149 @@ public List<T> find(final long offset, final long limit) {
     }
 
     /**
-     * Very efficient way to get just the IDs without creating any objects. IDs can later be used to lookup objects
-     * (lookups by ID are also very efficient in ObjectBox).
+     * Like {@link #findFirst()}, but returns just the ID of the object.
+     * <p>
+     * This is more efficient as no object is created.
+     * <p>
+     * Ignores any {@link QueryBuilder#filter(QueryFilter) query filter}.
+     *
+     * @return The ID of the first matching object. {@code 0} if no object matches.
+     */
+    public long findFirstId() {
+        checkOpen();
+        return box.internalCallWithReaderHandle(cursorHandle -> nativeFindFirstId(handle, cursorHandle));
+    }
+
+    /**
+     * Like {@link #findUnique()}, but returns just the ID of the object.
+     * <p>
+     * This is more efficient as no object is created.
+     * <p>
+     * Ignores any {@link QueryBuilder#filter(QueryFilter) query filter}.
+     *
+     * @return The ID of the object, if a single object matches. {@code 0} if no object matches. Throws
+     * {@link NonUniqueResultException} if there are multiple objects matching the query.
+     */
+    public long findUniqueId() {
+        checkOpen();
+        return box.internalCallWithReaderHandle(cursorHandle -> nativeFindUniqueId(handle, cursorHandle));
+    }
+
+    /**
+     * Like {@link #find()}, but returns just the IDs of the objects.
+     * <p>
+     * IDs can later be used to {@link Box#get} objects.
+     * <p>
+     * This is very efficient as no objects are created.
      * <p>
      * Note: a filter set with {@link QueryBuilder#filter(QueryFilter)} will be silently ignored!
+     *
+     * @return An array of IDs of matching objects. An empty array if no objects match.
      */
     @Nonnull
     public long[] findIds() {
-        return findIds(0,0);
+        return findIds(0, 0);
     }
 
     /**
-     * Like {@link #findIds()} but with a offset/limit param, e.g. for pagination.
+     * Like {@link #findIds()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
      * <p>
      * Note: a filter set with {@link QueryBuilder#filter(QueryFilter)} will be silently ignored!
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
      */
     @Nonnull
     public long[] findIds(final long offset, final long limit) {
+        checkOpen();
         return box.internalCallWithReaderHandle(cursorHandle -> nativeFindIds(handle, cursorHandle, offset, limit));
     }
 
     /**
-     * Find all Objects matching the query without actually loading the Objects. See @{@link LazyList} for details.
+     * Like {@link #findIds()}, but wraps the Object IDs in an unmodifiable {@link LazyList}
+     * so Objects can be retrieved on demand. The LazyList does not cache retrieved Objects, so only basic
+     * {@link List} operations like getting or iterating list items are supported. See {@link LazyList} for details.
      */
+    @Nonnull
     public LazyList<T> findLazy() {
         ensureNoFilterNoComparator();
         return new LazyList<>(box, findIds(), false);
     }
 
-    // TODO we might move all those property find methods in a "PropertyQuery" class for divide & conquer.
+    /**
+     * Like {@link #findIds()}, but wraps the Object IDs in an unmodifiable, caching {@link LazyList}
+     * so Objects can be retrieved on demand. The LazyList caches retrieved Objects supporting almost
+     * all {@link List} operations, at the expense of used memory. See {@link LazyList} for details.
+     */
+    @Nonnull
+    public LazyList<T> findLazyCached() {
+        ensureNoFilterNoComparator();
+        return new LazyList<>(box, findIds(), true);
+    }
+
+    /**
+     * Like {@link #findIdsWithScores()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
+     */
+    @Nonnull
+    public List<IdWithScore> findIdsWithScores(final long offset, final long limit) {
+        checkOpen();
+        return box.internalCallWithReaderHandle(cursorHandle -> nativeFindIdsWithScores(handle, cursorHandle, offset, limit));
+    }
+
+    /**
+     * Finds IDs of objects matching the query associated to their query score (e.g. distance in NN search).
+     * <p>
+     * This only works on objects with a property with an {@link HnswIndex}.
+     *
+     * @return A list of {@link IdWithScore} that wraps IDs of matching objects and their score, sorted by score in
+     * ascending order.
+     */
+    @Nonnull
+    public List<IdWithScore> findIdsWithScores() {
+        return findIdsWithScores(0, 0);
+    }
+
+    /**
+     * Like {@link #findWithScores()}, but can skip and limit results.
+     * <p>
+     * Use to get a slice of the whole result, e.g. for "result paging".
+     *
+     * @param offset If greater than 0, skips this many results.
+     * @param limit If greater than 0, returns at most this many results.
+     */
+    @Nonnull
+    public List<ObjectWithScore<T>> findWithScores(final long offset, final long limit) {
+        ensureNoFilterNoComparator();
+        return callInReadTx(() -> {
+            List<ObjectWithScore<T>> results = nativeFindWithScores(handle, cursorHandle(), offset, limit);
+            if (eagerRelations != null) {
+                for (int i = 0; i < results.size(); i++) {
+                    resolveEagerRelationForNonNullEagerRelations(results.get(i).get(), i);
+                }
+            }
+            return results;
+        });
+    }
+
+    /**
+     * Finds objects matching the query associated to their query score (e.g. distance in NN search).
+     * <p>
+     * This only works on objects with a property with an {@link HnswIndex}.
+     *
+     * @return A list of {@link ObjectWithScore} that wraps matching objects and their score, sorted by score in
+     * ascending order.
+     */
+    @Nonnull
+    public List<ObjectWithScore<T>> findWithScores() {
+        return findWithScores(0, 0);
+    }
 
     /**
      * Creates a {@link PropertyQuery} for the given property.
@@ -272,6 +465,7 @@ public PropertyQuery property(Property<T> property) {
     }
 
     <R> R callInReadTx(Callable<R> callable) {
+        checkOpen();
         return store.callInReadTxWithRetry(callable, queryAttempts, INITIAL_RETRY_BACK_OFF_IN_MS, true);
     }
 
@@ -286,6 +480,7 @@ <R> R callInReadTx(Callable<R> callable) {
      */
     public void forEach(final QueryConsumer<T> consumer) {
         ensureNoComparator();
+        checkOpen(); // findIds also checks, but throw early outside of transaction.
         box.getStore().runInReadTx(() -> {
             LazyList<T> lazyList = new LazyList<>(box, findIds(), false);
             int size = lazyList.size();
@@ -311,15 +506,6 @@ public void forEach(final QueryConsumer<T> consumer) {
         });
     }
 
-    /**
-     * Find all Objects matching the query without actually loading the Objects. See @{@link LazyList} for details.
-     */
-    @Nonnull
-    public LazyList<T> findLazyCached() {
-        ensureNoFilterNoComparator();
-        return new LazyList<>(box, findIds(), true);
-    }
-
     void resolveEagerRelations(List<T> entities) {
         if (eagerRelations != null) {
             int entityIndex = 0;
@@ -371,6 +557,7 @@ void resolveEagerRelation(@Nonnull T entity, EagerRelation<T, ?> eagerRelation)
 
     /** Returns the count of Objects matching the query. */
     public long count() {
+        checkOpen();
         ensureNoFilter();
         return box.internalCallWithReaderHandle(cursorHandle -> nativeCount(handle, cursorHandle));
     }
@@ -379,16 +566,19 @@ public long count() {
      * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
      */
     public Query<T> setParameter(Property<?> property, String value) {
+        checkOpen();
         nativeSetParameter(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, String value) {
+        checkOpen();
         nativeSetParameter(handle, 0, 0, alias, value);
         return this;
     }
@@ -397,16 +587,19 @@ public Query<T> setParameter(String alias, String value) {
      * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
      */
     public Query<T> setParameter(Property<?> property, long value) {
+        checkOpen();
         nativeSetParameter(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, long value) {
+        checkOpen();
         nativeSetParameter(handle, 0, 0, alias, value);
         return this;
     }
@@ -415,16 +608,19 @@ public Query<T> setParameter(String alias, long value) {
      * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
      */
     public Query<T> setParameter(Property<?> property, double value) {
+        checkOpen();
         nativeSetParameter(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, double value) {
+        checkOpen();
         nativeSetParameter(handle, 0, 0, alias, value);
         return this;
     }
@@ -439,9 +635,10 @@ public Query<T> setParameter(Property<?> property, Date value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      * @throws NullPointerException if given date is null
      */
     public Query<T> setParameter(String alias, Date value) {
@@ -456,65 +653,130 @@ public Query<T> setParameter(Property<?> property, boolean value) {
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to a new value.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, boolean value) {
         return setParameter(alias, value ? 1 : 0);
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code int[]} value to use for the query condition.
      */
-    public Query<T> setParameters(Property<?> property, long value1, long value2) {
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value1, value2);
+    public Query<T> setParameter(Property<?> property, int[] value) {
+        checkOpen();
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code int[]} value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, long value1, long value2) {
-        nativeSetParameters(handle, 0, 0, alias, value1, value2);
+    public Query<T> setParameter(String alias, int[] value) {
+        checkOpen();
+        nativeSetParameters(handle, 0, 0, alias, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code long[]} value to use for the query condition.
      */
-    public Query<T> setParameters(Property<?> property, int[] values) {
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, values);
+    public Query<T> setParameter(Property<?> property, long[] value) {
+        checkOpen();
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code long[]} value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, int[] values) {
-        nativeSetParameters(handle, 0, 0, alias, values);
+    public Query<T> setParameter(String alias, long[] value) {
+        checkOpen();
+        nativeSetParameters(handle, 0, 0, alias, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code float[]} value to use for the query condition.
      */
-    public Query<T> setParameters(Property<?> property, long[] values) {
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, values);
+    public Query<T> setParameter(Property<?> property, float[] value) {
+        checkOpen();
+        nativeSetParameter(handle, property.getEntityId(), property.getId(), null, value);
+        return this;
+    }
+
+    /**
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
+     *
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code float[]} value to use for the query condition.
+     */
+    public Query<T> setParameter(String alias, float[] value) {
+        checkOpen();
+        nativeSetParameter(handle, 0, 0, alias, value);
+        return this;
+    }
+
+    /**
+     * Changes the parameter of the query condition for {@code property} to a new {@code value}.
+     *
+     * @param property Property reference from generated entity underscore class, like {@code Example_.example}.
+     * @param value The new {@code String[]} value to use for the query condition.
+     */
+    public Query<T> setParameter(Property<?> property, String[] value) {
+        checkOpen();
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value);
+        return this;
+    }
+
+    /**
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
+     *
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new {@code String[]} value to use for the query condition.
+     */
+    public Query<T> setParameter(String alias, String[] value) {
+        checkOpen();
+        nativeSetParameters(handle, 0, 0, alias, value);
         return this;
     }
 
     /**
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     */
+    public Query<T> setParameters(Property<?> property, long value1, long value2) {
+        checkOpen();
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value1, value2);
+        return this;
+    }
+
+    /**
+     * Changes the parameters of the query condition with the matching {@code alias} to the new values.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value1 The first value to use for the query condition.
+     * @param value2 The second value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, long[] values) {
-        nativeSetParameters(handle, 0, 0, alias, values);
+    public Query<T> setParameters(String alias, long value1, long value2) {
+        checkOpen();
+        nativeSetParameters(handle, 0, 0, alias, value1, value2);
         return this;
     }
 
@@ -522,16 +784,20 @@ public Query<T> setParameters(String alias, long[] values) {
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
      */
     public Query<T> setParameters(Property<?> property, double value1, double value2) {
+        checkOpen();
         nativeSetParameters(handle, property.getEntityId(), property.getId(), null, value1, value2);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameters of the query condition with the matching {@code alias} to the new values.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value1 The first value to use for the query condition.
+     * @param value2 The second value to use for the query condition.
      */
     public Query<T> setParameters(String alias, double value1, double value2) {
+        checkOpen();
         nativeSetParameters(handle, 0, 0, alias, value1, value2);
         return this;
     }
@@ -539,18 +805,22 @@ public Query<T> setParameters(String alias, double value1, double value2) {
     /**
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
      */
-    public Query<T> setParameters(Property<?> property, String[] values) {
-        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, values);
+    public Query<T> setParameters(Property<?> property, String key, String value) {
+        checkOpen();
+        nativeSetParameters(handle, property.getEntityId(), property.getId(), null, key, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameters of the query condition with the matching {@code alias} to the new values.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param key The first value to use for the query condition.
+     * @param value The second value to use for the query condition.
      */
-    public Query<T> setParameters(String alias, String[] values) {
-        nativeSetParameters(handle, 0, 0, alias, values);
+    public Query<T> setParameters(String alias, String key, String value) {
+        checkOpen();
+        nativeSetParameters(handle, 0, 0, alias, key, value);
         return this;
     }
 
@@ -558,16 +828,19 @@ public Query<T> setParameters(String alias, String[] values) {
      * Sets a parameter previously given to the {@link QueryBuilder} to new values.
      */
     public Query<T> setParameter(Property<?> property, byte[] value) {
+        checkOpen();
         nativeSetParameter(handle, property.getEntityId(), property.getId(), null, value);
         return this;
     }
 
     /**
-     * Sets a parameter previously given to the {@link QueryBuilder} to new values.
+     * Changes the parameter of the query condition with the matching {@code alias} to a new {@code value}.
      *
-     * @param alias as defined using {@link QueryBuilder#parameterAlias(String)}.
+     * @param alias as defined using {@link PropertyQueryCondition#alias(String)}.
+     * @param value The new value to use for the query condition.
      */
     public Query<T> setParameter(String alias, byte[] value) {
+        checkOpen();
         nativeSetParameter(handle, 0, 0, alias, value);
         return this;
     }
@@ -578,30 +851,37 @@ public Query<T> setParameter(String alias, byte[] value) {
      * @return count of removed Objects
      */
     public long remove() {
+        checkOpen();
         ensureNoFilter();
         return box.internalCallWithWriterHandle(cursorHandle -> nativeRemove(handle, cursorHandle));
     }
 
     /**
-     * A {@link io.objectbox.reactive.DataObserver} can be subscribed to data changes using the returned builder.
-     * The observer is supplied via {@link SubscriptionBuilder#observer(DataObserver)} and will be notified once
-     * the query results have (potentially) changed.
+     * Returns a {@link SubscriptionBuilder} to build a subscription to observe changes to the results of this query.
      * <p>
-     * With subscribing, the observer will immediately get current query results.
-     * The query is run for the subscribing observer.
+     * Typical usage:
+     * <pre>
+     * DataSubscription subscription = query.subscribe()
+     *         .observer((List&lt;T&gt; data) -> {
+     *               // Do something with the returned results
+     *         });
+     * // Once the observer should no longer be notified
+     * subscription.cancel();
+     * </pre>
+     * Note that the observer will receive new results on any changes to the {@link Box} of the {@link Entity @Entity}
+     * this queries, regardless of the conditions of this query. This is because the {@link QueryPublisher} used for the
+     * subscription observes changes by using {@link BoxStore#subscribe(Class)} on the Box this queries.
      * <p>
-     * Threading notes:
-     * Query observers are notified from a thread pooled. Observers may be notified in parallel.
-     * The notification order is the same as the subscription order, although this may not always be guaranteed in
-     * the future.
+     * To customize this or for advanced use cases, consider using {@link BoxStore#subscribe(Class)} directly.
      * <p>
-     * Stale observers: you must hold on to the Query or {@link io.objectbox.reactive.DataSubscription} objects to keep
-     * your {@link DataObserver}s active. If this Query is not referenced anymore
-     * (along with its {@link io.objectbox.reactive.DataSubscription}s, which hold a reference to the Query internally),
-     * it may be GCed and observers may become stale (won't receive anymore data).
+     * See {@link SubscriptionBuilder#observer(DataObserver)} for additional details.
+     *
+     * @return A {@link SubscriptionBuilder} to build a subscription.
+     * @see #publish()
      */
     public SubscriptionBuilder<List<T>> subscribe() {
-        return new SubscriptionBuilder<>(publisher, null, box.getStore().internalThreadPool());
+        checkOpen();
+        return new SubscriptionBuilder<>(publisher, null);
     }
 
     /**
@@ -617,11 +897,15 @@ public SubscriptionBuilder<List<T>> subscribe(DataSubscriptionList dataSubscript
     }
 
     /**
-     * Publishes the current data to all subscribed @{@link DataObserver}s.
-     * This is useful triggering observers when new parameters have been set.
-     * Note, that setParameter methods will NOT be propagated to observers.
+     * Manually schedules publishing the current results of this query to all {@link #subscribe() subscribed}
+     * {@link DataObserver observers}, even if the underlying Boxes have not changed.
+     * <p>
+     * This is useful to publish new results after changing parameters of this query which would otherwise not trigger
+     * publishing of new results.
      */
     public void publish() {
+        // Do open check to not silently fail (publisher runnable would just not get scheduled if query is closed)
+        checkOpen();
         publisher.publish();
     }
 
@@ -632,6 +916,7 @@ public void publish() {
      * Note: the format of the returned string may change without notice.
      */
     public String describe() {
+        checkOpen();
         return nativeToString(handle);
     }
 
@@ -642,7 +927,17 @@ public String describe() {
      * Note: the format of the returned string may change without notice.
      */
     public String describeParameters() {
+        checkOpen();
         return nativeDescribeParameters(handle);
     }
 
+    /**
+     * Throws if {@link #close()} has been called for this.
+     */
+    private void checkOpen() {
+        if (handle == 0) {
+            throw new IllegalStateException("This query is closed. Build and use a new one.");
+        }
+    }
+
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java b/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java
index 64fd65c9..0f61c45d 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,6 @@
 
 package io.objectbox.query;
 
-import java.io.Closeable;
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.Date;
@@ -27,33 +26,55 @@
 import io.objectbox.Box;
 import io.objectbox.EntityInfo;
 import io.objectbox.Property;
-import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.exception.DbException;
 import io.objectbox.relation.RelationInfo;
 
 /**
- * With QueryBuilder you define custom queries returning matching entities. Using the methods of this class you can
- * select (filter) results for specific data (for example #{@link #equal(Property, String)} and
- * {@link #isNull(Property)}) and select an sort order for the resulting list (see {@link #order(Property)} and its
- * overloads).
+ * Builds a {@link Query Query} using conditions which can then be used to return a list of matching Objects.
  * <p>
- * Use {@link #build()} to conclude your query definitions and to get a {@link Query} object, which is used to actually
- * get results.
+ * A simple example:
+ *
+ * <pre>
+ * userBox.query()
+ *     .equal(User_.firstName, "Joe", StringOrder.CASE_SENSITIVE)
+ *     .order(User_.lastName)
+ *     .build()
+ *     .find()
+ * </pre>
+ *
+ * <p>
+ * To add a condition use the appropriate method, for example {@link #equal(Property, String, StringOrder)} or
+ * {@link #isNull(Property)}. To order results use {@link #order(Property)} and its related methods.
  * <p>
- * Note: Currently you can only query for complete entities. Returning individual property values or aggregates are
- * currently not available. Keep in mind that ObjectBox is very fast and the overhead to create an entity is very low.
+ * Use {@link #build()} to create a {@link Query} object, which is used to actually get the results.
+ * <p>
+ * Note: by default Query returns full Objects. To return only values or an aggregate value for a single Property,
+ * use {@link Query#property(Property)}.
+ * <p>
+ * See the <a href="https://docs.objectbox.io/queries">Queries documentation</a> for details.
  *
- * @param <T> Entity class associated with this query builder.
+ * @param <T> Entity class for which the Query is built.
  */
 @SuppressWarnings({"WeakerAccess", "UnusedReturnValue", "unused"})
-@Experimental
-public class QueryBuilder<T> implements Closeable {
+public class QueryBuilder<T> {
 
     public enum StringOrder {
-        /** The default: case insensitive ASCII characters */
+        /**
+         * Ignores case of ASCII characters when matching results,
+         * e.g. the condition "= example" matches both "Example" and "example".
+         * <p>
+         * Note: To utilize an index on a property use {@link #CASE_SENSITIVE} instead.
+         */
         CASE_INSENSITIVE,
 
-        /** Case matters ('a' != 'A'). */
+        /**
+         * Checks case of ASCII characters when matching results,
+         * e.g. the condition "= example" only matches "example", but not "Example".
+         * <p>
+         * Use this if the property has an {@link io.objectbox.annotation.Index @Index}
+         * to dramatically increase the speed of looking-up results.
+         */
         CASE_SENSITIVE
     }
 
@@ -130,6 +151,9 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native void nativeSetParameterAlias(long conditionHandle, String alias);
 
+    private native long nativeRelationCount(long handle, long storeHandle, int relationOwnerEntityId, int propertyId,
+                                            int relationCount);
+
     // ------------------------------ (Not)Null------------------------------
 
     private native long nativeNull(long handle, int propertyId);
@@ -142,9 +166,9 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeNotEqual(long handle, int propertyId, long value);
 
-    private native long nativeLess(long handle, int propertyId, long value);
+    private native long nativeLess(long handle, int propertyId, long value, boolean withEqual);
 
-    private native long nativeGreater(long handle, int propertyId, long value);
+    private native long nativeGreater(long handle, int propertyId, long value, boolean withEqual);
 
     private native long nativeBetween(long handle, int propertyId, long value1, long value2);
 
@@ -152,6 +176,16 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeIn(long handle, int propertyId, long[] values, boolean negate);
 
+    private native long nativeEqualKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeGreaterKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeGreaterEqualsKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeLessKeyValue(long handle, int propertyId, String key, long value);
+
+    private native long nativeLessEqualsKeyValue(long handle, int propertyId, String key, long value);
+
     // ------------------------------ Strings ------------------------------
 
     private native long nativeEqual(long handle, int propertyId, String value, boolean caseSensitive);
@@ -160,37 +194,62 @@ private native long nativeLink(long handle, long storeHandle, int relationOwnerE
 
     private native long nativeContains(long handle, int propertyId, String value, boolean caseSensitive);
 
+    private native long nativeContainsElement(long handle, int propertyId, String value, boolean caseSensitive);
+
+    private native long nativeEqualKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeGreaterKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeGreaterEqualsKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeLessKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
+    private native long nativeLessEqualsKeyValue(long handle, int propertyId, String key, String value, boolean caseSensitive);
+
     private native long nativeStartsWith(long handle, int propertyId, String value, boolean caseSensitive);
 
     private native long nativeEndsWith(long handle, int propertyId, String value, boolean caseSensitive);
 
-    private native long nativeLess(long handle, int propertyId, String value, boolean caseSensitive);
+    private native long nativeLess(long handle, int propertyId, String value, boolean caseSensitive, boolean withEqual);
 
-    private native long nativeGreater(long handle, int propertyId, String value, boolean caseSensitive);
+    private native long nativeGreater(long handle, int propertyId, String value, boolean caseSensitive, boolean withEqual);
 
     private native long nativeIn(long handle, int propertyId, String[] value, boolean caseSensitive);
 
     // ------------------------------ FPs ------------------------------
 
-    private native long nativeLess(long handle, int propertyId, double value);
+    private native long nativeLess(long handle, int propertyId, double value, boolean withEqual);
 
-    private native long nativeGreater(long handle, int propertyId, double value);
+    private native long nativeGreater(long handle, int propertyId, double value, boolean withEqual);
 
     private native long nativeBetween(long handle, int propertyId, double value1, double value2);
 
+    private native long nativeNearestNeighborsF32(long handle, int propertyId, float[] queryVector, int maxResultCount);
+
+    private native long nativeEqualKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeGreaterKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeGreaterEqualsKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeLessKeyValue(long handle, int propertyId, String key, double value);
+
+    private native long nativeLessEqualsKeyValue(long handle, int propertyId, String key, double value);
+
     // ------------------------------ Bytes ------------------------------
 
     private native long nativeEqual(long handle, int propertyId, byte[] value);
 
-    private native long nativeLess(long handle, int propertyId, byte[] value);
+    private native long nativeLess(long handle, int propertyId, byte[] value, boolean withEqual);
 
-    private native long nativeGreater(long handle, int propertyId, byte[] value);
+    private native long nativeGreater(long handle, int propertyId, byte[] value, boolean withEqual);
 
     @Internal
     public QueryBuilder(Box<T> box, long storeHandle, String entityName) {
         this.box = box;
         this.storeHandle = storeHandle;
         handle = nativeCreate(storeHandle, entityName);
+        if (handle == 0) throw new DbException("Could not create native query builder");
         isSubQuery = false;
     }
 
@@ -202,7 +261,9 @@ private QueryBuilder(long storeHandle, long subQueryBuilderHandle) {
     }
 
     /**
-     * Explicitly call {@link #close()} instead to avoid expensive finalization.
+     * Typically {@link #build()} is called on this which calls {@link #close()} and avoids expensive finalization here.
+     * <p>
+     * If {@link #build()} is not called, make sure to explicitly call {@link #close()}.
      */
     @SuppressWarnings("deprecation") // finalize()
     @Override
@@ -211,6 +272,12 @@ protected void finalize() throws Throwable {
         super.finalize();
     }
 
+    /**
+     * Close this query builder and free used resources.
+     * <p>
+     * This is not required when calling {@link #build()}.
+     */
+    // Not implementing (Auto)Closeable as QueryBuilder is typically closed due to build() getting called.
     public synchronized void close() {
         if (handle != 0) {
             // Closeable recommendation: mark as "closed" before nativeDestroy could throw.
@@ -232,6 +299,7 @@ public Query<T> build() {
             throw new IllegalStateException("Incomplete logic condition. Use or()/and() between two conditions only.");
         }
         long queryHandle = nativeBuild(handle);
+        if (queryHandle == 0) throw new DbException("Could not create native query");
         Query<T> query = new Query<>(box, queryHandle, eagerRelations, filter, comparator);
         close();
         return query;
@@ -249,6 +317,29 @@ private void verifyHandle() {
         }
     }
 
+    /**
+     * Applies the given query conditions and returns the builder for further customization, such as result order.
+     * Build the condition using the properties from your entity underscore classes.
+     * <p>
+     * An example with a nested OR condition:
+     * <pre>
+     * # Java
+     * builder.apply(User_.name.equal("Jane")
+     *         .and(User_.age.less(12)
+     *                 .or(User_.status.equal("child"))));
+     *
+     * # Kotlin
+     * builder.apply(User_.name.equal("Jane")
+     *         and (User_.age.less(12)
+     *         or User_.status.equal("child")))
+     * </pre>
+     * Use {@link Box#query(QueryCondition)} as a shortcut for this method.
+     */
+    public QueryBuilder<T> apply(QueryCondition<T> queryCondition) {
+        ((QueryConditionImpl<T>) queryCondition).apply(this);
+        return this;
+    }
+
     /**
      * Specifies given property to be used for sorting.
      * Shorthand for {@link #order(Property, int)} with flags equal to 0.
@@ -293,10 +384,7 @@ public QueryBuilder<T> orderDesc(Property<T> property) {
     public QueryBuilder<T> order(Property<T> property, int flags) {
         verifyNotSubQuery();
         verifyHandle();
-        if (combineNextWith != Operator.NONE) {
-            throw new IllegalStateException(
-                    "An operator is pending. Use operators like and() and or() only between two conditions.");
-        }
+        checkNoOperatorPending();
         nativeOrder(handle, property.getId(), flags);
         return this;
     }
@@ -308,7 +396,10 @@ public QueryBuilder<T> sort(Comparator<T> comparator) {
 
 
     /**
-     * Asigns the given alias to the previous condition.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
+     * Assigns the given alias to the previous condition.
      *
      * @param alias The string alias for use with setParameter(s) methods.
      */
@@ -367,12 +458,12 @@ public <TARGET> QueryBuilder<TARGET> backlink(RelationInfo<TARGET, ?> relationIn
 
     /**
      * Specifies relations that should be resolved eagerly.
-     * This prepares the given relation objects to be preloaded (cached) avoiding further get operations from the db.
-     * A common use case is prealoading all
+     * This prepares the given relation objects to be preloaded (cached) avoiding further get operations from the database.
      *
      * @param relationInfo The relation as found in the generated meta info class ("EntityName_") of class T.
      * @param more         Supply further relations to be eagerly loaded.
      */
+    @SuppressWarnings("rawtypes")
     public QueryBuilder<T> eager(RelationInfo relationInfo, RelationInfo... more) {
         return eager(0, relationInfo, more);
     }
@@ -384,6 +475,7 @@ public QueryBuilder<T> eager(RelationInfo relationInfo, RelationInfo... more) {
      * @param relationInfo The relation as found in the generated meta info class ("EntityName_") of class T.
      * @param more         Supply further relations to be eagerly loaded.
      */
+    @SuppressWarnings({"rawtypes", "unchecked"})
     public QueryBuilder<T> eager(int limit, RelationInfo relationInfo, @Nullable RelationInfo... more) {
         verifyNotSubQuery();
         if (eagerRelations == null) {
@@ -400,7 +492,7 @@ public QueryBuilder<T> eager(int limit, RelationInfo relationInfo, @Nullable Rel
 
     /**
      * Sets a filter that executes on primary query results (returned from the db core) on a Java level.
-     * For efficiency reasons, you should always prefer primary criteria like {@link #equal(Property, String)} if
+     * For efficiency reasons, you should always prefer primary criteria like {@link #equal(Property, long)} if
      * possible.
      * A filter requires to instantiate full Java objects beforehand, which is less efficient.
      * <p>
@@ -468,13 +560,19 @@ public QueryBuilder<T> and() {
     }
 
     private void combineOperator(Operator operator) {
+        verifyHandle(); // Not using handle, but throw for consistency with other methods.
         if (lastCondition == 0) {
             throw new IllegalStateException("No previous condition. Use operators like and() and or() only between two conditions.");
         }
+        checkNoOperatorPending();
+        combineNextWith = operator;
+    }
+
+    private void checkNoOperatorPending() {
         if (combineNextWith != Operator.NONE) {
-            throw new IllegalStateException("Another operator is pending. Use operators like and() and or() only between two conditions.");
+            throw new IllegalStateException(
+                    "Another operator is pending. Use operators like and() and or() only between two conditions.");
         }
-        combineNextWith = operator;
     }
 
     private void checkCombineCondition(long currentCondition) {
@@ -488,153 +586,297 @@ private void checkCombineCondition(long currentCondition) {
         lastPropertyCondition = currentCondition;
     }
 
+    @Internal
+    long internalGetLastCondition() {
+        return lastCondition;
+    }
+
+    @Internal
+    void internalAnd(long leftCondition, long rightCondition) {
+        lastCondition = nativeCombine(handle, leftCondition, rightCondition, false);
+    }
+
+    @Internal
+    void internalOr(long leftCondition, long rightCondition) {
+        lastCondition = nativeCombine(handle, leftCondition, rightCondition, true);
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> isNull(Property<T> property) {
         verifyHandle();
         checkCombineCondition(nativeNull(handle, property.getId()));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> notNull(Property<T> property) {
         verifyHandle();
         checkCombineCondition(nativeNotNull(handle, property.getId()));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> relationCount(RelationInfo<T, ?> relationInfo, int relationCount) {
+        verifyHandle();
+        checkCombineCondition(nativeRelationCount(handle, storeHandle, relationInfo.targetInfo.getEntityId(),
+                relationInfo.targetIdProperty.id, relationCount));
+        return this;
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                              Integers
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> equal(Property<T> property, long value) {
         verifyHandle();
         checkCombineCondition(nativeEqual(handle, property.getId(), value));
         return this;
     }
 
-    public QueryBuilder<T> equal(Property<T> property, boolean value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> notEqual(Property<T> property, long value) {
         verifyHandle();
-        checkCombineCondition(nativeEqual(handle, property.getId(), value ? 1 : 0));
+        checkCombineCondition(nativeNotEqual(handle, property.getId(), value));
         return this;
     }
 
-    /** @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead. */
-    public QueryBuilder<T> equal(Property<T> property, Date value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> less(Property<T> property, long value) {
         verifyHandle();
-        checkCombineCondition(nativeEqual(handle, property.getId(), value.getTime()));
+        checkCombineCondition(nativeLess(handle, property.getId(), value, false));
         return this;
     }
 
-    public QueryBuilder<T> notEqual(Property<T> property, long value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> lessOrEqual(Property<T> property, long value) {
         verifyHandle();
-        checkCombineCondition(nativeNotEqual(handle, property.getId(), value));
+        checkCombineCondition(nativeLess(handle, property.getId(), value, true));
         return this;
     }
 
-    public QueryBuilder<T> notEqual(Property<T> property, boolean value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> greater(Property<T> property, long value) {
         verifyHandle();
-        checkCombineCondition(nativeNotEqual(handle, property.getId(), value ? 1 : 0));
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, false));
         return this;
     }
 
-    /** @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead. */
-    public QueryBuilder<T> notEqual(Property<T> property, Date value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> greaterOrEqual(Property<T> property, long value) {
         verifyHandle();
-        checkCombineCondition(nativeNotEqual(handle, property.getId(), value.getTime()));
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, true));
         return this;
     }
 
-    public QueryBuilder<T> less(Property<T> property, long value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
+     * Finds objects with property value between and including the first and second value.
+     */
+    public QueryBuilder<T> between(Property<T> property, long value1, long value2) {
         verifyHandle();
-        checkCombineCondition(nativeLess(handle, property.getId(), value));
+        checkCombineCondition(nativeBetween(handle, property.getId(), value1, value2));
         return this;
     }
 
-    public QueryBuilder<T> greater(Property<T> property, long value) {
+    // FIXME DbException: invalid unordered_map<K, T> key
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> in(Property<T> property, long[] values) {
         verifyHandle();
-        checkCombineCondition(nativeGreater(handle, property.getId(), value));
+        checkCombineCondition(nativeIn(handle, property.getId(), values, false));
         return this;
     }
 
-    public QueryBuilder<T> less(Property<T> property, Date value) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> notIn(Property<T> property, long[] values) {
         verifyHandle();
-        checkCombineCondition(nativeLess(handle, property.getId(), value.getTime()));
+        checkCombineCondition(nativeIn(handle, property.getId(), values, true));
         return this;
     }
 
-    /** @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead. */
-    public QueryBuilder<T> greater(Property<T> property, Date value) {
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Integers -> int[]
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> in(Property<T> property, int[] values) {
         verifyHandle();
-        checkCombineCondition(nativeGreater(handle, property.getId(), value.getTime()));
+        checkCombineCondition(nativeIn(handle, property.getId(), values, false));
         return this;
     }
 
-    public QueryBuilder<T> between(Property<T> property, long value1, long value2) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> notIn(Property<T> property, int[] values) {
         verifyHandle();
-        checkCombineCondition(nativeBetween(handle, property.getId(), value1, value2));
+        checkCombineCondition(nativeIn(handle, property.getId(), values, true));
         return this;
     }
 
-    /** @throws NullPointerException if one of the given values is null. */
-    public QueryBuilder<T> between(Property<T> property, Date value1, Date value2) {
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Integers -> boolean
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> equal(Property<T> property, boolean value) {
         verifyHandle();
-        checkCombineCondition(nativeBetween(handle, property.getId(), value1.getTime(), value2.getTime()));
+        checkCombineCondition(nativeEqual(handle, property.getId(), value ? 1 : 0));
         return this;
     }
 
-    // FIXME DbException: invalid unordered_map<K, T> key
-    public QueryBuilder<T> in(Property<T> property, long[] values) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> notEqual(Property<T> property, boolean value) {
         verifyHandle();
-        checkCombineCondition(nativeIn(handle, property.getId(), values, false));
+        checkCombineCondition(nativeNotEqual(handle, property.getId(), value ? 1 : 0));
         return this;
     }
 
-    public QueryBuilder<T> in(Property<T> property, int[] values) {
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // Integers -> Date
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
+     * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
+     */
+    public QueryBuilder<T> equal(Property<T> property, Date value) {
         verifyHandle();
-        checkCombineCondition(nativeIn(handle, property.getId(), values, false));
+        checkCombineCondition(nativeEqual(handle, property.getId(), value.getTime()));
         return this;
     }
 
-    public QueryBuilder<T> notIn(Property<T> property, long[] values) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
+     * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
+     */
+    public QueryBuilder<T> notEqual(Property<T> property, Date value) {
         verifyHandle();
-        checkCombineCondition(nativeIn(handle, property.getId(), values, true));
+        checkCombineCondition(nativeNotEqual(handle, property.getId(), value.getTime()));
         return this;
     }
 
-    public QueryBuilder<T> notIn(Property<T> property, int[] values) {
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
+     * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
+     */
+    public QueryBuilder<T> less(Property<T> property, Date value) {
         verifyHandle();
-        checkCombineCondition(nativeIn(handle, property.getId(), values, true));
+        checkCombineCondition(nativeLess(handle, property.getId(), value.getTime(), false));
         return this;
     }
 
-    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    //                                              String
-    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
+     * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
+     */
+    public QueryBuilder<T> lessOrEqual(Property<T> property, Date value) {
+        verifyHandle();
+        checkCombineCondition(nativeLess(handle, property.getId(), value.getTime(), true));
+        return this;
+    }
 
     /**
-     * Creates an "equal ('=')" condition for this property.
-     * <p>
-     * Ignores case when matching results, e.g. {@code equal(prop, "example")} matches both "Example" and "example".
-     * <p>
-     * Use {@link #equal(Property, String, StringOrder) equal(prop, value, StringOrder.CASE_SENSITIVE)} to only match
-     * if case is equal.
-     * <p>
-     * Note: Use a case sensitive condition to utilize an {@link io.objectbox.annotation.Index @Index}
-     * on {@code property}, dramatically speeding up look-up of results.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
+     * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
      */
-    public QueryBuilder<T> equal(Property<T> property, String value) {
+    public QueryBuilder<T> greater(Property<T> property, Date value) {
         verifyHandle();
-        checkCombineCondition(nativeEqual(handle, property.getId(), value, false));
+        checkCombineCondition(nativeGreater(handle, property.getId(), value.getTime(), false));
         return this;
     }
 
     /**
-     * Creates an "equal ('=')" condition for this property.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     *
+     * @throws NullPointerException if given value is null. Use {@link #isNull(Property)} instead.
+     */
+    public QueryBuilder<T> greaterOrEqual(Property<T> property, Date value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreater(handle, property.getId(), value.getTime(), true));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      * <p>
-     * Set {@code order} to {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to only match
-     * if case is equal. E.g. {@code equal(prop, "example", StringOrder.CASE_SENSITIVE)} only matches "example",
-     * but not "Example".
+     * Finds objects with property value between and including the first and second value.
+     *
+     * @throws NullPointerException if one of the given values is null.
+     */
+    public QueryBuilder<T> between(Property<T> property, Date value1, Date value2) {
+        verifyHandle();
+        checkCombineCondition(nativeBetween(handle, property.getId(), value1.getTime(), value2.getTime()));
+        return this;
+    }
+
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    //                                              String
+    ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      * <p>
-     * Note: Use a case sensitive condition to utilize an {@link io.objectbox.annotation.Index @Index}
-     * on {@code property}, dramatically speeding up look-up of results.
+     * Creates an "equal ('=')" condition for this property.
      */
     public QueryBuilder<T> equal(Property<T> property, String value, StringOrder order) {
         verifyHandle();
@@ -643,80 +885,221 @@ public QueryBuilder<T> equal(Property<T> property, String value, StringOrder ord
     }
 
     /**
-     * Creates a "not equal ('&lt;&gt;')" condition for this property.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      * <p>
-     * Ignores case when matching results, e.g. {@code notEqual(prop, "example")} excludes both "Example" and "example".
+     * Creates a "not equal ('&lt;&gt;')" condition for this property.
+     */
+    public QueryBuilder<T> notEqual(Property<T> property, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeNotEqual(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      * <p>
-     * Use {@link #notEqual(Property, String, StringOrder) notEqual(prop, value, StringOrder.CASE_SENSITIVE)} to only exclude
-     * if case is equal.
+     * Creates a contains condition.
      * <p>
-     * Note: Use a case sensitive condition to utilize an {@link io.objectbox.annotation.Index @Index}
-     * on {@code property}, dramatically speeding up look-up of results.
+     * Note: for a String array property, use {@link #containsElement} instead.
      */
-    public QueryBuilder<T> notEqual(Property<T> property, String value) {
+    public QueryBuilder<T> contains(Property<T> property, String value, StringOrder order) {
+        if (String[].class == property.type) {
+            throw new UnsupportedOperationException("For String[] only containsElement() is supported at this time.");
+        }
         verifyHandle();
-        checkCombineCondition(nativeNotEqual(handle, property.getId(), value, false));
+        checkCombineCondition(nativeContains(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
     /**
-     * Creates a "not equal ('&lt;&gt;')" condition for this property.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      * <p>
-     * Set {@code order} to {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to only exclude
-     * if case is equal. E.g. {@code notEqual(prop, "example", StringOrder.CASE_SENSITIVE)} only excludes "example",
-     * but not "Example".
-     * <p>
-     * Note: Use a case sensitive condition to utilize an {@link io.objectbox.annotation.Index @Index}
-     * on {@code property}, dramatically speeding up look-up of results.
+     * For a String array, list or String-key map property, matches if at least one element equals the given value.
      */
-    public QueryBuilder<T> notEqual(Property<T> property, String value, StringOrder order) {
+    public QueryBuilder<T> containsElement(Property<T> property, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeNotEqual(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
+        checkCombineCondition(nativeContainsElement(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
     /**
-     * Ignores case when matching results. Use the overload and pass
-     * {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to specify that case should not be ignored.
+     * @deprecated Use {@link Property#equalKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
      */
-    public QueryBuilder<T> contains(Property<T> property, String value) {
+    @Deprecated
+    public QueryBuilder<T> containsKeyValue(Property<T> property, String key, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeContains(handle, property.getId(), value, false));
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
     /**
-     * Ignores case when matching results. Use the overload and pass
-     * {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to specify that case should not be ignored.
+     * Note: Use {@link Property#equalKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
      */
-    public QueryBuilder<T> startsWith(Property<T> property, String value) {
+    public QueryBuilder<T> equalKeyValue(Property<T> property, String key, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeStartsWith(handle, property.getId(), value, false));
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
     /**
-     * Ignores case when matching results. Use the overload and pass
-     * {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to specify that case should not be ignored.
+     * Note: Use {@link Property#lessKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
      */
-    public QueryBuilder<T> endsWith(Property<T> property, String value) {
+    public QueryBuilder<T> lessKeyValue(Property<T> property, String key, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeEndsWith(handle, property.getId(), value, false));
+        checkCombineCondition(nativeLessKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
-    public QueryBuilder<T> contains(Property<T> property, String value, StringOrder order) {
+    /**
+     * Note: Use {@link Property#lessOrEqualKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessOrEqualKeyValue(Property<T> property, String key, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeContains(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
+        checkCombineCondition(nativeLessEqualsKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
+    /**
+     * Note: Use {@link Property#greaterKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterOrEqualKeyValue(Property<T> property, String key, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterEqualsKeyValue(handle, property.getId(), key, value, order == StringOrder.CASE_SENSITIVE));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#equalKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> equalKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessOrEqualKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessOrEqualKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, long)} (String, String, StringOrder)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, long)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterOrEqualKeyValue(Property<T> property, String key, long value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#equalKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> equalKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeEqualKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#lessOrEqualKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> lessOrEqualKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeLessEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * Note: Use {@link Property#greaterOrEqualKeyValue(String, double)} with the
+     * {@link Box#query(QueryCondition) new query API} instead.
+     */
+    public QueryBuilder<T> greaterOrEqualKeyValue(Property<T> property, String key, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreaterEqualsKeyValue(handle, property.getId(), key, value));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> startsWith(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeStartsWith(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> endsWith(Property<T> property, String value, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeEndsWith(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
@@ -724,41 +1107,49 @@ public QueryBuilder<T> endsWith(Property<T> property, String value, StringOrder
     }
 
     /**
-     * Ignores case when matching results. Use the overload and pass
-     * {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to specify that case should not be ignored.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      */
-    public QueryBuilder<T> less(Property<T> property, String value) {
-        return less(property, value, StringOrder.CASE_INSENSITIVE);
-    }
-
     public QueryBuilder<T> less(Property<T> property, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeLess(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
+        checkCombineCondition(nativeLess(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, false));
         return this;
     }
 
     /**
-     * Ignores case when matching results. Use the overload and pass
-     * {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to specify that case should not be ignored.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      */
-    public QueryBuilder<T> greater(Property<T> property, String value) {
-        return greater(property, value, StringOrder.CASE_INSENSITIVE);
+    public QueryBuilder<T> lessOrEqual(Property<T> property, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeLess(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, true));
+        return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, String value, StringOrder order) {
         verifyHandle();
-        checkCombineCondition(nativeGreater(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE));
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, false));
         return this;
     }
 
     /**
-     * Ignores case when matching results. Use the overload and pass
-     * {@link StringOrder#CASE_SENSITIVE StringOrder.CASE_SENSITIVE} to specify that case should not be ignored.
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
      */
-    public QueryBuilder<T> in(Property<T> property, String[] values) {
-        return in(property, values, StringOrder.CASE_INSENSITIVE);
+    public QueryBuilder<T> greaterOrEqual(Property<T> property, String value, StringOrder order) {
+        verifyHandle();
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, order == StringOrder.CASE_SENSITIVE, true));
+        return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> in(Property<T> property, String[] values, StringOrder order) {
         verifyHandle();
         checkCombineCondition(nativeIn(handle, property.getId(), values, order == StringOrder.CASE_SENSITIVE));
@@ -773,6 +1164,9 @@ public QueryBuilder<T> in(Property<T> property, String[] values, StringOrder ord
     // Help people with floating point equality...
 
     /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
      * Floating point equality is non-trivial; this is just a convenience for
      * {@link #between(Property, double, double)} with parameters(property, value - tolerance, value + tolerance).
      * When using {@link Query#setParameters(Property, double, double)},
@@ -782,43 +1176,119 @@ public QueryBuilder<T> equal(Property<T> property, double value, double toleranc
         return between(property, value - tolerance, value + tolerance);
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> less(Property<T> property, double value) {
         verifyHandle();
-        checkCombineCondition(nativeLess(handle, property.getId(), value));
+        checkCombineCondition(nativeLess(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> lessOrEqual(Property<T> property, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeLess(handle, property.getId(), value, true));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, double value) {
         verifyHandle();
-        checkCombineCondition(nativeGreater(handle, property.getId(), value));
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, false));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> greaterOrEqual(Property<T> property, double value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, true));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     * <p>
+     * Finds objects with property value between and including the first and second value.
+     */
     public QueryBuilder<T> between(Property<T> property, double value1, double value2) {
         verifyHandle();
         checkCombineCondition(nativeBetween(handle, property.getId(), value1, value2));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> nearestNeighbors(Property<T> property, float[] queryVector, int maxResultCount) {
+        verifyHandle();
+        checkCombineCondition(nativeNearestNeighborsF32(handle, property.getId(), queryVector, maxResultCount));
+        return this;
+    }
+
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
     //                                                 Bytes
     ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> equal(Property<T> property, byte[] value) {
         verifyHandle();
         checkCombineCondition(nativeEqual(handle, property.getId(), value));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> less(Property<T> property, byte[] value) {
         verifyHandle();
-        checkCombineCondition(nativeLess(handle, property.getId(), value));
+        checkCombineCondition(nativeLess(handle, property.getId(), value, false));
         return this;
     }
 
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> lessOrEqual(Property<T> property, byte[] value) {
+        verifyHandle();
+        checkCombineCondition(nativeLess(handle, property.getId(), value, true));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
     public QueryBuilder<T> greater(Property<T> property, byte[] value) {
         verifyHandle();
-        checkCombineCondition(nativeGreater(handle, property.getId(), value));
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, false));
+        return this;
+    }
+
+    /**
+     * <b>Note:</b> New code should use the {@link Box#query(QueryCondition) new query API}. Existing code can continue
+     * to use this, there are currently no plans to remove the old query API.
+     */
+    public QueryBuilder<T> greaterOrEqual(Property<T> property, byte[] value) {
+        verifyHandle();
+        checkCombineCondition(nativeGreater(handle, property.getId(), value, true));
         return this;
     }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java b/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java
index d721820c..b4b5a6dc 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryCondition.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2016-2020 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -13,258 +13,29 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package io.objectbox.query;
-
-import java.util.Date;
 
-import javax.annotation.Nullable;
+package io.objectbox.query;
 
 import io.objectbox.Property;
-import io.objectbox.annotation.apihint.Experimental;
-import io.objectbox.annotation.apihint.Internal;
-import io.objectbox.exception.DbException;
-import io.objectbox.query.QueryBuilder.StringOrder;
 
 /**
- * Internal interface to model WHERE conditions used in queries. Use the {@link Property} objects in the DAO classes to
- * create new conditions.
+ * Allows building queries with a fluent interface. Use through {@link io.objectbox.Box#query(QueryCondition)}
+ * and build a condition with {@link Property} methods.
  */
-@Experimental
-@Internal
-public interface QueryCondition {
-
-    void applyTo(QueryBuilder queryBuilder, StringOrder stringOrder);
-
-    void setParameterFor(Query query, Object parameter);
-
-    void setParameterFor(Query query, Object parameter1, Object parameter2);
-
-    abstract class AbstractCondition implements QueryCondition {
-
-        public final Object value;
-        protected final Object[] values;
-
-        AbstractCondition(Object value) {
-            this.value = value;
-            this.values = null;
-        }
-
-        AbstractCondition(@Nullable Object[] values) {
-            this.value = null;
-            this.values = values;
-        }
-
-    }
-
-    class PropertyCondition extends AbstractCondition {
-
-        public enum Operation {
-            EQUALS,
-            NOT_EQUALS,
-            BETWEEN,
-            IN,
-            GREATER_THAN,
-            LESS_THAN,
-            IS_NULL,
-            IS_NOT_NULL,
-            CONTAINS,
-            STARTS_WITH,
-            ENDS_WITH
-        }
-
-        public final Property property;
-        private final Operation operation;
-
-        public PropertyCondition(Property property, Operation operation, @Nullable Object value) {
-            super(checkValueForType(property, value));
-            this.property = property;
-            this.operation = operation;
-        }
-
-        public PropertyCondition(Property property, Operation operation, @Nullable Object[] values) {
-            super(checkValuesForType(property, operation, values));
-            this.property = property;
-            this.operation = operation;
-        }
-
-        public void applyTo(QueryBuilder queryBuilder, StringOrder stringOrder) {
-            if (operation == Operation.EQUALS) {
-                if (value instanceof Long) {
-                    queryBuilder.equal(property, (Long) value);
-                } else if (value instanceof Integer) {
-                    queryBuilder.equal(property, (Integer) value);
-                } else if (value instanceof String) {
-                    queryBuilder.equal(property, (String) value, stringOrder);
-                }
-            } else if (operation == Operation.NOT_EQUALS) {
-                if (value instanceof Long) {
-                    queryBuilder.notEqual(property, (Long) value);
-                } else if (value instanceof Integer) {
-                    queryBuilder.notEqual(property, (Integer) value);
-                } else if (value instanceof String) {
-                    queryBuilder.notEqual(property, (String) value, stringOrder);
-                }
-            } else if (operation == Operation.BETWEEN) {
-                if (values[0] instanceof Long && values[1] instanceof Long) {
-                    queryBuilder.between(property, (Long) values[0], (Long) values[1]);
-                } else if (values[0] instanceof Integer && values[1] instanceof Integer) {
-                    queryBuilder.between(property, (Integer) values[0], (Integer) values[1]);
-                } else if (values[0] instanceof Double && values[1] instanceof Double) {
-                    queryBuilder.between(property, (Double) values[0], (Double) values[1]);
-                } else if (values[0] instanceof Float && values[1] instanceof Float) {
-                    queryBuilder.between(property, (Float) values[0], (Float) values[1]);
-                }
-            } else if (operation == Operation.IN) {
-                // just check the first value and assume all others are of the same type
-                // maybe this is too naive and we should properly check values earlier
-                if (values[0] instanceof Long) {
-                    long[] inValues = new long[values.length];
-                    for (int i = 0; i < values.length; i++) {
-                        inValues[i] = (long) values[i];
-                    }
-                    queryBuilder.in(property, inValues);
-                } else if (values[0] instanceof Integer) {
-                    int[] inValues = new int[values.length];
-                    for (int i = 0; i < values.length; i++) {
-                        inValues[i] = (int) values[i];
-                    }
-                    queryBuilder.in(property, inValues);
-                }
-            } else if (operation == Operation.GREATER_THAN) {
-                if (value instanceof Long) {
-                    queryBuilder.greater(property, (Long) value);
-                } else if (value instanceof Integer) {
-                    queryBuilder.greater(property, (Integer) value);
-                } else if (value instanceof Double) {
-                    queryBuilder.greater(property, (Double) value);
-                } else if (value instanceof Float) {
-                    queryBuilder.greater(property, (Float) value);
-                }
-            } else if (operation == Operation.LESS_THAN) {
-                if (value instanceof Long) {
-                    queryBuilder.less(property, (Long) value);
-                } else if (value instanceof Integer) {
-                    queryBuilder.less(property, (Integer) value);
-                } else if (value instanceof Double) {
-                    queryBuilder.less(property, (Double) value);
-                } else if (value instanceof Float) {
-                    queryBuilder.less(property, (Float) value);
-                }
-            } else if (operation == Operation.IS_NULL) {
-                queryBuilder.isNull(property);
-            } else if (operation == Operation.IS_NOT_NULL) {
-                queryBuilder.notNull(property);
-            } else if (operation == Operation.CONTAINS) {
-                // no need for greenDAO compat, so only String was allowed
-                queryBuilder.contains(property, (String) value, stringOrder);
-            } else if (operation == Operation.STARTS_WITH) {
-                // no need for greenDAO compat, so only String was allowed
-                queryBuilder.startsWith(property, (String) value, stringOrder);
-            } else if (operation == Operation.ENDS_WITH) {
-                // no need for greenDAO compat, so only String was allowed
-                queryBuilder.endsWith(property, (String) value, stringOrder);
-            } else {
-                throw new UnsupportedOperationException("This operation is not known.");
-            }
-        }
-
-        private static Object checkValueForType(Property property, @Nullable Object value) {
-            if (value != null && value.getClass().isArray()) {
-                throw new DbException("Illegal value: found array, but simple object required");
-            }
-            Class<?> type = property.type;
-            if (type == Date.class) {
-                if (value instanceof Date) {
-                    return ((Date) value).getTime();
-                } else if (value instanceof Long) {
-                    return value;
-                } else {
-                    throw new DbException("Illegal date value: expected java.util.Date or Long for value " + value);
-                }
-            } else if (property.type == boolean.class || property.type == Boolean.class) {
-                if (value instanceof Boolean) {
-                    return ((Boolean) value) ? 1 : 0;
-                } else if (value instanceof Number) {
-                    int intValue = ((Number) value).intValue();
-                    if (intValue != 0 && intValue != 1) {
-                        throw new DbException("Illegal boolean value: numbers must be 0 or 1, but was " + value);
-                    }
-                } else if (value instanceof String) {
-                    String stringValue = ((String) value);
-                    if ("TRUE".equalsIgnoreCase(stringValue)) {
-                        return 1;
-                    } else if ("FALSE".equalsIgnoreCase(stringValue)) {
-                        return 0;
-                    } else {
-                        throw new DbException(
-                                "Illegal boolean value: Strings must be \"TRUE\" or \"FALSE\" (case insensitive), but was "
-                                        + value);
-                    }
-                }
-            }
-            return value;
-        }
-
-        private static Object[] checkValuesForType(Property property, Operation operation, @Nullable Object[] values) {
-            if (values == null) {
-                if (operation == Operation.IS_NULL || operation == Operation.IS_NOT_NULL) {
-                    return null;
-                } else {
-                    throw new IllegalArgumentException("This operation requires non-null values.");
-                }
-            }
-            for (int i = 0; i < values.length; i++) {
-                values[i] = checkValueForType(property, values[i]);
-            }
-            return values;
-        }
-
-        @Override
-        public void setParameterFor(Query query, Object parameter) {
-            if (parameter == null) {
-                throw new IllegalArgumentException("The new parameter can not be null.");
-            }
-            if (operation == Operation.BETWEEN) {
-                throw new UnsupportedOperationException("The BETWEEN condition requires two parameters.");
-            }
-            if (operation == Operation.IN) {
-                throw new UnsupportedOperationException("The IN condition does not support changing parameters.");
-            }
-            if (parameter instanceof Long) {
-                query.setParameter(property, (Long) parameter);
-            } else if (parameter instanceof Integer) {
-                query.setParameter(property, (Integer) parameter);
-            } else if (parameter instanceof String) {
-                query.setParameter(property, (String) parameter);
-            } else if (parameter instanceof Double) {
-                query.setParameter(property, (Double) parameter);
-            } else if (parameter instanceof Float) {
-                query.setParameter(property, (Float) parameter);
-            } else {
-                throw new IllegalArgumentException("Only LONG, INTEGER, DOUBLE, FLOAT or STRING parameters are supported.");
-            }
-        }
-
-        @Override
-        public void setParameterFor(Query query, Object parameter1, Object parameter2) {
-            if (parameter1 == null || parameter2 == null) {
-                throw new IllegalArgumentException("The new parameters can not be null.");
-            }
-            if (operation != Operation.BETWEEN) {
-                throw new UnsupportedOperationException("Only the BETWEEN condition supports two parameters.");
-            }
-            if (parameter1 instanceof Long && parameter2 instanceof Long) {
-                query.setParameters(property, (Long) parameter1, (Long) parameter2);
-            } else if (parameter1 instanceof Integer && parameter2 instanceof Integer) {
-                query.setParameters(property, (Integer) parameter1, (Integer) parameter2);
-            }  else if (parameter1 instanceof Double && parameter2 instanceof Double) {
-                query.setParameters(property, (Double) parameter1, (Double) parameter2);
-            }  else if (parameter1 instanceof Float && parameter2 instanceof Float) {
-                query.setParameters(property, (Float) parameter1, (Float) parameter2);
-            } else {
-                throw new IllegalArgumentException("The BETWEEN condition only supports LONG, INTEGER, DOUBLE or FLOAT parameters.");
-            }
-        }
-    }
+public interface QueryCondition<T> {
+
+    /**
+     * Combines this condition using AND with the given condition.
+     *
+     * @see #or(QueryCondition)
+     */
+    QueryCondition<T> and(QueryCondition<T> queryCondition);
+
+    /**
+     * Combines this condition using OR with the given condition.
+     *
+     * @see #and(QueryCondition)
+     */
+    QueryCondition<T> or(QueryCondition<T> queryCondition);
 
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java b/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java
new file mode 100644
index 00000000..2d7ded81
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryConditionImpl.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.query.LogicQueryCondition.AndCondition;
+import io.objectbox.query.LogicQueryCondition.OrCondition;
+
+/**
+ * Hides the {@link #apply(QueryBuilder)} method from the public API ({@link QueryCondition}).
+ */
+abstract class QueryConditionImpl<T> implements QueryCondition<T> {
+
+    @Override
+    public QueryCondition<T> and(QueryCondition<T> queryCondition) {
+        return new AndCondition<>(this, (QueryConditionImpl<T>) queryCondition);
+    }
+
+    @Override
+    public QueryCondition<T> or(QueryCondition<T> queryCondition) {
+        return new OrCondition<>(this, (QueryConditionImpl<T>) queryCondition);
+    }
+
+    abstract void apply(QueryBuilder<T> builder);
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java b/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java
index 255d0a66..24fd53de 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryConsumer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java b/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java
index b60349b2..86213a34 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryFilter.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java b/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java
index 9a5bd19a..7f1eb75f 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,9 @@
 
 package io.objectbox.query;
 
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.CopyOnWriteArraySet;
@@ -29,13 +32,44 @@
 import io.objectbox.reactive.DataPublisher;
 import io.objectbox.reactive.DataPublisherUtils;
 import io.objectbox.reactive.DataSubscription;
+import io.objectbox.reactive.SubscriptionBuilder;
 
+/**
+ * A {@link DataPublisher} that {@link BoxStore#subscribe(Class) subscribes to the Box} of its associated {@link Query}
+ * while there is at least one observer (see {@link #subscribe(DataObserver, Object)} and
+ * {@link #unsubscribe(DataObserver, Object)}).
+ * <p>
+ * Publishing is requested if the Box reports changes, a subscription is
+ * {@link SubscriptionBuilder#observer(DataObserver) observed} (if {@link #publishSingle(DataObserver, Object)} is
+ * called) or {@link Query#publish()} (calls {@link #publish()}) is called.
+ * <p>
+ * For publishing the query is re-run and the result data is delivered to the current observers.
+ * <p>
+ * Data is passed to observers on a single thread ({@link BoxStore#internalScheduleThread(Runnable)}), one at a time, in
+ * the order observers were added.
+ */
 @Internal
-class QueryPublisher<T> implements DataPublisher<List<T>> {
+class QueryPublisher<T> implements DataPublisher<List<T>>, Runnable {
 
+    /**
+     * If enabled, logs states of the publisher runnable. Useful to debug a query subscription.
+     */
+    public static boolean LOG_STATES = false;
     private final Query<T> query;
     private final Box<T> box;
     private final Set<DataObserver<List<T>>> observers = new CopyOnWriteArraySet<>();
+    private final Deque<DataObserver<List<T>>> publishQueue = new ArrayDeque<>();
+    private volatile boolean publisherRunning = false;
+    private volatile boolean publisherStopped = false;
+
+    private static class SubscribedObservers<T> implements DataObserver<List<T>> {
+        @Override
+        public void onData(List<T> data) {
+        }
+    }
+
+    /** Placeholder observer to use if all subscribed observers should be notified. */
+    private final SubscribedObservers<T> SUBSCRIBED_OBSERVERS = new SubscribedObservers<>();
 
     private DataObserver<Class<T>> objectClassObserver;
     private DataSubscription objectClassSubscription;
@@ -71,20 +105,112 @@ public synchronized void subscribe(DataObserver<List<T>> observer, @Nullable Obj
     }
 
     @Override
-    public void publishSingle(final DataObserver<List<T>> observer, @Nullable Object param) {
-        box.getStore().internalScheduleThread(() -> {
-            List<T> result = query.find();
-            observer.onData(result);
-        });
+    public void publishSingle(DataObserver<List<T>> observer, @Nullable Object param) {
+        queueObserverAndScheduleRun(observer);
     }
 
     void publish() {
-        box.getStore().internalScheduleThread(() -> {
-            List<T> result = query.find();
-            for (DataObserver<List<T>> observer : observers) {
-                observer.onData(result);
+        queueObserverAndScheduleRun(SUBSCRIBED_OBSERVERS);
+    }
+
+    /**
+     * Non-blocking: will just enqueue the changes for a separate thread.
+     */
+    private void queueObserverAndScheduleRun(DataObserver<List<T>> observer) {
+        synchronized (publishQueue) {
+            // Check after obtaining the lock as the publisher may have been stopped while waiting on the lock
+            if (publisherStopped) {
+                return;
+            }
+            publishQueue.add(observer);
+            if (!publisherRunning) {
+                publisherRunning = true;
+                box.getStore().internalScheduleThread(this);
             }
-        });
+        }
+    }
+
+    /**
+     * Marks this publisher as stopped and if it is currently running waits on it to complete.
+     * <p>
+     * After calling this, this publisher will no longer run, even if observers subscribe or publishing is requested.
+     */
+    void stopAndAwait() {
+        publisherStopped = true;
+        // Doing wait/notify waiting here; could also use the Future from BoxStore.internalScheduleThread() instead.
+        // The latter would require another member though, which seems redundant.
+        synchronized (this) {
+            while (publisherRunning) {
+                try {
+                    this.wait();
+                } catch (InterruptedException e) {
+                    if (publisherRunning) {
+                        // When called by Query.close() throwing here will leak the query. But not throwing would allow
+                        // close() to proceed in destroying the native query while it may still be active (run() of this
+                        // is at the query.find() call), which would trigger a VM crash.
+                        throw new RuntimeException("Interrupted while waiting for publisher to finish", e);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Processes publish requests for this query on a single thread to prevent
+     * older query results getting delivered after newer query results.
+     * To speed up processing each loop publishes to all queued observers instead of just the next in line.
+     * This reduces time spent querying and waiting for DataObserver.onData() and their potential DataTransformers.
+     */
+    @Override
+    public void run() {
+        log("started");
+        try {
+            while (!publisherStopped) {
+                // Get all queued observer(s), stop processing if none.
+                log("checking for observers");
+                List<DataObserver<List<T>>> singlePublishObservers = new ArrayList<>();
+                boolean notifySubscribedObservers = false;
+                synchronized (publishQueue) {
+                    DataObserver<List<T>> nextObserver;
+                    while ((nextObserver = publishQueue.poll()) != null) {
+                        if (SUBSCRIBED_OBSERVERS.equals(nextObserver)) {
+                            notifySubscribedObservers = true;
+                        } else {
+                            singlePublishObservers.add(nextObserver);
+                        }
+                    }
+                    if (!notifySubscribedObservers && singlePublishObservers.isEmpty()) {
+                        publisherRunning = false;
+                        break; // Stop.
+                    }
+                }
+
+                // Query.
+                log("running query");
+                if (publisherStopped) break;  // Check again to avoid running the query if possible
+                List<T> result = query.find();
+
+                // Notify observer(s).
+                log("notifying observers");
+                for (DataObserver<List<T>> observer : singlePublishObservers) {
+                    observer.onData(result);
+                }
+                if (notifySubscribedObservers) {
+                    // Use current list of observers to avoid notifying unsubscribed observers.
+                    Set<DataObserver<List<T>>> observers = this.observers;
+                    for (DataObserver<List<T>> dataObserver : observers) {
+                        dataObserver.onData(result);
+                    }
+                }
+            }
+        } finally {
+            log("stopped");
+            // Re-set if wrapped code throws, otherwise this publisher can no longer publish.
+            publisherRunning = false;
+            synchronized (this) {
+                this.notifyAll();
+            }
+        }
     }
 
     @Override
@@ -96,4 +222,8 @@ public synchronized void unsubscribe(DataObserver<List<T>> observer, @Nullable O
         }
     }
 
+    private static void log(String message) {
+        if (LOG_STATES) System.out.println("QueryPublisher: " + message);
+    }
+
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java b/objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java
new file mode 100644
index 00000000..9bef4ec5
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/QueryThreadLocal.java
@@ -0,0 +1,22 @@
+package io.objectbox.query;
+
+/**
+ * A {@link ThreadLocal} that, given an original {@link Query} object,
+ * returns a {@link Query#copy() copy}, for each thread.
+ */
+public class QueryThreadLocal<T> extends ThreadLocal<Query<T>> {
+
+    private final Query<T> original;
+
+    /**
+     * See {@link QueryThreadLocal}.
+     */
+    public QueryThreadLocal(Query<T> original) {
+        this.original = original;
+    }
+
+    @Override
+    protected Query<T> initialValue() {
+        return original.copy();
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java b/objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java
new file mode 100644
index 00000000..86d5e38c
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/query/RelationCountCondition.java
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2022 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.relation.RelationInfo;
+
+public class RelationCountCondition<T> extends QueryConditionImpl<T> {
+
+    private final RelationInfo<T, ?> relationInfo;
+    private final int relationCount;
+
+
+    public RelationCountCondition(RelationInfo<T, ?> relationInfo, int relationCount) {
+        this.relationInfo = relationInfo;
+        this.relationCount = relationCount;
+    }
+
+    @Override
+    void apply(QueryBuilder<T> builder) {
+        builder.relationCount(relationInfo, relationCount);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/query/package-info.java b/objectbox-java/src/main/java/io/objectbox/query/package-info.java
index 7530a37c..86a3bf23 100644
--- a/objectbox-java/src/main/java/io/objectbox/query/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/query/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java
index 3c5dac41..2ab7f534 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java
index f57950ce..001753fe 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java
index 496b172a..a6f08298 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataPublisherUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java
index 26b12fe8..54b2dedf 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscription.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java
index fc7a15fe..5b854cf1 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionImpl.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java
index 40d19e24..59e63dde 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataSubscriptionList.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java b/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java
index 35a3f9c8..4d65d9b9 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DataTransformer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,17 +16,16 @@
 
 package io.objectbox.reactive;
 
-import javax.annotation.Nullable;
-
 /**
  * Transforms or processes data before it is given to subscribed {@link DataObserver}s. A transformer is set via
  * {@link SubscriptionBuilder#transform(DataTransformer)}.
- *
+ * <p>
  * Note that a transformer is not required to actually "transform" any data.
  * Technically, it's fine to return the same data it received and just do some processing with it.
- *
- * Threading notes: Note that the transformer is always executed asynchronously.
- * It is OK to perform long lasting operations.
+ * <p>
+ * Threading notes: transformations are executed sequentially on a background thread
+ * owned by the subscription publisher. It is OK to perform long lasting operations,
+ * however this will block notifications to all other observers until finished.
  *
  * @param <FROM> Data type this transformer receives
  * @param <TO> Type of transformed data
@@ -34,6 +33,7 @@
 public interface DataTransformer<FROM, TO> {
     /**
      * Transforms/processes the given data.
+     *
      * @param source data to be transformed
      * @return transformed data
      * @throws Exception Transformers may throw any exceptions, which can be reacted on via
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java
index b771a5a7..3263d86a 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/DelegatingObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java
index 2b1b245d..8d1de9c8 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/ErrorObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java b/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java
index 90059cf9..03cdd43e 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/RunWithParam.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java b/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java
index fb1b25ac..7f478a1d 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/Scheduler.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,5 +17,5 @@
 package io.objectbox.reactive;
 
 public interface Scheduler {
-    <T> void run(RunWithParam runnable, T param);
+    <T> void run(RunWithParam<T> runnable, T param);
 }
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java b/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java
index 8461acce..e095f462 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/Schedulers.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java b/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java
index eed98557..9760128d 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/SubscriptionBuilder.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,18 +16,17 @@
 
 package io.objectbox.reactive;
 
-import java.util.concurrent.ExecutorService;
-
 import javax.annotation.Nullable;
 
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.query.Query;
 
 /**
  * Builds a {@link DataSubscription} for a {@link DataObserver} passed via {@link #observer(DataObserver)}.
  * Note that the call to {@link #observer(DataObserver)} is mandatory to create the subscription -
  * if you forget it, nothing will happen.
  * <p>
- * When subscribing to a data source such as {@link io.objectbox.query.Query}, this builder allows to configure:
+ * When subscribing to a data source such as {@link Query}, this builder allows to configure:
  * <ul>
  * <li>weakly referenced observer via {@link #weak()}</li>
  * <li>a data transform operation via {@link #transform(DataTransformer)}</li>
@@ -44,7 +43,6 @@
 public class SubscriptionBuilder<T> {
     private final DataPublisher<T> publisher;
     private final Object publisherParam;
-    private final ExecutorService threadPool;
     private DataObserver<T> observer;
     //    private Runnable firstRunnable;
     private boolean weak;
@@ -58,10 +56,9 @@ public class SubscriptionBuilder<T> {
 
 
     @Internal
-    public SubscriptionBuilder(DataPublisher<T> publisher, @Nullable Object param, ExecutorService threadPool) {
+    public SubscriptionBuilder(DataPublisher<T> publisher, @Nullable Object param) {
         this.publisher = publisher;
         publisherParam = param;
-        this.threadPool = threadPool;
     }
 
     //    public Observable<T> runFirst(Runnable firstRunnable) {
@@ -82,11 +79,21 @@ public SubscriptionBuilder<T> weak() {
         return this;
     }
 
+    /**
+     * Only deliver the latest data once, do not subscribe for data changes.
+     *
+     * @see #onlyChanges()
+     */
     public SubscriptionBuilder<T> single() {
         single = true;
         return this;
     }
 
+    /**
+     * Upon subscribing do not deliver the latest data, only once there are changes.
+     *
+     * @see #single()
+     */
     public SubscriptionBuilder<T> onlyChanges() {
         onlyChanges = true;
         return this;
@@ -98,14 +105,12 @@ public SubscriptionBuilder<T> onlyChanges() {
     //    }
 
     /**
-     * Transforms the original data from the publisher to something that is more helpful to your application.
-     * The transformation is done in an asynchronous thread.
-     * The observer will be called in the same asynchronous thread unless a Scheduler is defined using
-     * {@link #on(Scheduler)}.
+     * Transforms the original data from the publisher to some other type.
+     * All transformations run sequentially in an asynchronous thread owned by the publisher.
      * <p>
-     * This is roughly equivalent to the map operator as known in Rx and Kotlin.
+     * This is similar to the map operator of Rx and Kotlin.
      *
-     * @param <TO> The class the data is transformed to
+     * @param <TO> The type data is transformed to.
      */
     public <TO> SubscriptionBuilder<TO> transform(final DataTransformer<T, TO> transformer) {
         if (this.transformer != null) {
@@ -143,11 +148,20 @@ public SubscriptionBuilder<T> on(Scheduler scheduler) {
     }
 
     /**
-     * The given observer is subscribed to the publisher. This method MUST be called to complete a subscription.
+     * Completes building the subscription by setting a {@link DataObserver} that receives the data.
      * <p>
-     * Note: you must keep the returned {@link DataSubscription} to cancel it.
-     *
-     * @return an subscription object used for canceling further notifications to the observer
+     * By default, requests the latest data to be delivered immediately and on any future updates. To change this call
+     * {@link #single()} or {@link #onlyChanges()} before.
+     * <p>
+     * By default, {@link DataObserver#onData(Object)} is called from an internal background thread. Change this by
+     * setting a custom scheduler using {@link #on(Scheduler)}. It may also get called for multiple observers at the
+     * same time. The order in which observers are called is the same as the subscription order, although this may
+     * change in the future.
+     * <p>
+     * Typically, keep a reference to the returned {@link DataSubscription} to avoid it getting garbage collected, to
+     * keep receiving new data.
+     * <p>
+     * Call {@link DataSubscription#cancel()} once the observer should no longer receive data.
      */
     public DataSubscription observer(DataObserver<T> observer) {
         WeakDataObserver<T> weakObserver = null;
@@ -160,7 +174,7 @@ public DataSubscription observer(DataObserver<T> observer) {
             weakObserver.setSubscription(subscription);
         }
 
-        if(dataSubscriptionList != null) {
+        if (dataSubscriptionList != null) {
             dataSubscriptionList.add(subscription);
         }
 
@@ -190,6 +204,10 @@ public SubscriptionBuilder<T> dataSubscriptionList(DataSubscriptionList dataSubs
         return this;
     }
 
+    /**
+     * Wraps a {@link DataObserver} supplied to {@link #observer(DataObserver)} to support result
+     * transformation, an error observer or scheduler for result delivery.
+     */
     class ActionObserver implements DataObserver<T>, DelegatingObserver<T> {
         private final DataSubscriptionImpl subscription;
         private SchedulerRunOnError schedulerRunOnError;
@@ -214,19 +232,27 @@ public void onData(final T data) {
             }
         }
 
+        /**
+         * Runs on the thread of the {@link #onData(Object)} caller to ensure data is delivered
+         * in the same order as {@link #onData(Object)} was called, to prevent delivering stale data.
+         * <p>
+         * For both ObjectClassPublisher and QueryPublisher this is the asynchronous
+         * thread publish requests are processed on.
+         * <p>
+         * This could be optimized in the future to allow parallel execution,
+         * but this would require an ordering mechanism for the transformed data.
+         */
         private void transformAndContinue(final T data) {
-            threadPool.submit(() -> {
-                if (subscription.isCanceled()) {
-                    return;
-                }
-                try {
-                    // Type erasure FTW
-                    T result = (T) transformer.transform(data);
-                    callOnData(result);
-                } catch (Throwable th) {
-                    callOnError(th, "Transformer failed without an ErrorObserver set");
-                }
-            });
+            if (subscription.isCanceled()) {
+                return;
+            }
+            try {
+                // Type erasure FTW
+                T result = (T) transformer.transform(data);
+                callOnData(result);
+            } catch (Throwable th) {
+                callOnError(th, "Transformer failed without an ErrorObserver set");
+            }
         }
 
         private void callOnError(Throwable th, String msgNoErrorObserver) {
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java b/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java
index cdffbed2..a11f57af 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/WeakDataObserver.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java b/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java
index b89cb0b5..57a0bb94 100644
--- a/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/reactive/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 /**
  * Classes to {@link io.objectbox.reactive.SubscriptionBuilder configure}
- * a {@link io.objectbox.reactive.DataSubscription} for observing box or query changes.
+ * a {@link io.objectbox.reactive.DataSubscription} for observing Box or Query changes.
  * <p>
  * For more details look at the documentation of individual classes and
  * <a href="https://docs.objectbox.io/data-observers-and-rx">docs.objectbox.io/data-observers-and-rx</a>.
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java b/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java
index b7a12a98..b6666e4c 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/ListFactory.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java b/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java
index 09386908..8c47ffe3 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/RelationInfo.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,6 +25,8 @@
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.internal.ToManyGetter;
 import io.objectbox.internal.ToOneGetter;
+import io.objectbox.query.QueryCondition;
+import io.objectbox.query.RelationCountCondition;
 
 /**
  * Meta info describing a relation including source and target entity.
@@ -44,16 +46,16 @@ public class RelationInfo<SOURCE, TARGET> implements Serializable {
     public final int targetRelationId;
 
     /** Only set for ToOne relations */
-    public final ToOneGetter<SOURCE> toOneGetter;
+    public final ToOneGetter<SOURCE, TARGET> toOneGetter;
 
     /** Only set for ToMany relations */
-    public final ToManyGetter<SOURCE> toManyGetter;
+    public final ToManyGetter<SOURCE, TARGET> toManyGetter;
 
     /** For ToMany relations based on ToOne backlinks (null otherwise). */
-    public final ToOneGetter<TARGET> backlinkToOneGetter;
+    public final ToOneGetter<TARGET, SOURCE> backlinkToOneGetter;
 
     /** For ToMany relations based on ToMany backlinks (null otherwise). */
-    public final ToManyGetter<TARGET> backlinkToManyGetter;
+    public final ToManyGetter<TARGET, SOURCE> backlinkToManyGetter;
 
     /** For stand-alone to-many relations (0 otherwise). */
     public final int relationId;
@@ -62,7 +64,7 @@ public class RelationInfo<SOURCE, TARGET> implements Serializable {
      * ToOne
      */
     public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, Property<SOURCE> targetIdProperty,
-                        ToOneGetter<SOURCE> toOneGetter) {
+                        ToOneGetter<SOURCE, TARGET> toOneGetter) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
         this.targetIdProperty = targetIdProperty;
@@ -77,8 +79,8 @@ public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo
     /**
      * ToMany as a ToOne backlink
      */
-    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE> toManyGetter,
-                        Property<TARGET> targetIdProperty, ToOneGetter<TARGET> backlinkToOneGetter) {
+    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE, TARGET> toManyGetter,
+                        Property<TARGET> targetIdProperty, ToOneGetter<TARGET, SOURCE> backlinkToOneGetter) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
         this.targetIdProperty = targetIdProperty;
@@ -93,8 +95,8 @@ public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo
     /**
      * ToMany as a ToMany backlink
      */
-    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE> toManyGetter,
-            ToManyGetter<TARGET> backlinkToManyGetter, int targetRelationId) {
+    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE, TARGET> toManyGetter,
+                        ToManyGetter<TARGET, SOURCE> backlinkToManyGetter, int targetRelationId) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
         this.toManyGetter = toManyGetter;
@@ -109,7 +111,7 @@ public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo
     /**
      * Stand-alone ToMany.
      */
-    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE> toManyGetter,
+    public RelationInfo(EntityInfo<SOURCE> sourceInfo, EntityInfo<TARGET> targetInfo, ToManyGetter<SOURCE, TARGET> toManyGetter,
                         int relationId) {
         this.sourceInfo = sourceInfo;
         this.targetInfo = targetInfo;
@@ -130,5 +132,31 @@ public boolean isBacklink() {
     public String toString() {
         return "RelationInfo from " + sourceInfo.getEntityClass() + " to " + targetInfo.getEntityClass();
     }
+
+    /**
+     * Creates a condition to match objects that have {@code relationCount} related objects pointing to them.
+     * <pre>
+     * try (Query&lt;Customer&gt; query = customerBox
+     *         .query(Customer_.orders.relationCount(2))
+     *         .build()) {
+     *     List&lt;Customer&gt; customersWithTwoOrders = query.find();
+     * }
+     * </pre>
+     * {@code relationCount} may be 0 to match objects that do not have related objects.
+     * It typically should be a low number.
+     * <p>
+     * This condition has some limitations:
+     * <ul>
+     *     <li>only 1:N (ToMany using @Backlink) relations are supported,</li>
+     *     <li>the complexity is {@code O(n * (relationCount + 1))} and cannot be improved via indexes,</li>
+     *     <li>the relation count cannot be changed with setParameter once the query is built.</li>
+     * </ul>
+     */
+    public QueryCondition<SOURCE> relationCount(int relationCount) {
+        if (targetIdProperty == null) {
+            throw new IllegalStateException("The relation count condition is only supported for 1:N (ToMany using @Backlink) relations.");
+        }
+        return new RelationCountCondition<>(this, relationCount);
+    }
 }
 
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java b/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java
index 79b4e19f..508490e3 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/ToMany.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,6 @@
  */
 package io.objectbox.relation;
 
-import io.objectbox.internal.ToManyGetter;
 import java.io.Serializable;
 import java.lang.reflect.Field;
 import java.util.ArrayList;
@@ -36,30 +35,76 @@
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
 import io.objectbox.InternalAccess;
+import io.objectbox.annotation.Backlink;
+import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.apihint.Beta;
 import io.objectbox.annotation.apihint.Experimental;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbDetachedException;
 import io.objectbox.internal.IdGetter;
 import io.objectbox.internal.ReflectionCache;
+import io.objectbox.internal.ToManyGetter;
 import io.objectbox.internal.ToOneGetter;
+import io.objectbox.query.QueryBuilder;
 import io.objectbox.query.QueryFilter;
 import io.objectbox.relation.ListFactory.CopyOnWriteArrayListFactory;
 
 import static java.lang.Boolean.TRUE;
 
 /**
- * A List representing a to-many relation.
- * It tracks changes (adds and removes) that can be later applied (persisted) to the database.
- * This happens either on {@link Box#put(Object)} of the source entity of this relation or using
- * {@link #applyChangesToDb()}.
+ * A to-many relation of an entity that references multiple objects of a {@link TARGET} entity.
+ * <p>
+ * Example:
+ * <pre>{@code
+ * // Java
+ * @Entity
+ * public class Student {
+ *     private ToMany<Teacher> teachers;
+ * }
+ *
+ * // Kotlin
+ * @Entity
+ * data class Student() {
+ *     lateinit var teachers: ToMany<Teacher>
+ * }
+ * }</pre>
+ * <p>
+ * Implements the {@link List} interface and uses lazy initialization. The target objects are only read from the
+ * database when the list is first accessed.
+ * <p>
+ * The required database query runs on the calling thread, so avoid accessing ToMany from a UI or main thread. To get the
+ * latest data {@link Box#get} the object with the ToMany again or use {@link #reset()} before accessing the list again.
+ * It is possible to preload the list when running a query using {@link QueryBuilder#eager}.
+ * <p>
+ * Tracks when target objects are added and removed. Common usage:
+ * <ul>
+ * <li>{@link #add(Object)} to add target objects to the relation.
+ * <li>{@link #remove(Object)} to remove target objects from the relation.
+ * <li>{@link #remove(int)} to remove target objects at a specific index.
+ * </ul>
  * <p>
- * If this relation is a backlink from a {@link ToOne} relation, a DB sync will also update ToOne objects
- * (but not vice versa).
+ * To apply (persist) the changes to the database, call {@link #applyChangesToDb()} or put the object with the ToMany.
+ * For important details, see the notes about relations of {@link Box#put(Object)}.
+ * <pre>{@code
+ * // Example 1: add target objects to a relation
+ * student.getTeachers().add(teacher1);
+ * student.getTeachers().add(teacher2);
+ * store.boxFor(Student.class).put(student);
+ *
+ * // Example 2: remove a target object from the relation
+ * student.getTeachers().remove(index);
+ * student.getTeachers().applyChangesToDb();
+ * // or store.boxFor(Student.class).put(student);
+ * }</pre>
+ * <p>
+ * In the database, the target objects are referenced by their IDs, which are persisted as part of the relation of the
+ * object with the ToMany.
  * <p>
- * ToMany is thread-safe by default (only if the default {@link java.util.concurrent.CopyOnWriteArrayList} is used).
+ * ToMany is thread-safe by default (may not be the case if {@link #setListFactory(ListFactory)} is used).
+ * <p>
+ * To get all objects with a ToMany that reference a target object, see {@link Backlink}.
  *
- * @param <TARGET> Object type (entity).
+ * @param <TARGET> target object type ({@link Entity @Entity} class).
  */
 public class ToMany<TARGET> implements List<TARGET>, Serializable {
     private static final long serialVersionUID = 2367317778240689006L;
@@ -147,8 +192,8 @@ private void ensureBoxes() {
             try {
                 boxStore = (BoxStore) boxStoreField.get(entity);
                 if (boxStore == null) {
-                    throw new DbDetachedException("Cannot resolve relation for detached entities, " +
-                            "call box.attach(entity) beforehand.");
+                    throw new DbDetachedException("Cannot resolve relation for detached objects, " +
+                            "call box.attach(object) beforehand.");
                 }
             } catch (IllegalAccessException e) {
                 throw new RuntimeException(e);
@@ -218,9 +263,10 @@ private void ensureEntities() {
     }
 
     /**
-     * Adds the given entity to the list and tracks the addition so it can be later applied to the database
-     * (e.g. via {@link Box#put(Object)} of the entity owning the ToMany, or via {@link #applyChangesToDb()}).
-     * Note that the given entity will remain unchanged at this point (e.g. to-ones are not updated).
+     * Prepares to add the given target object to this relation.
+     * <p>
+     * To apply changes, call {@link #applyChangesToDb()} or put the object with the ToMany. For important details, see
+     * the notes about relations of {@link Box#put(Object)}.
      */
     @Override
     public synchronized boolean add(TARGET object) {
@@ -321,8 +367,9 @@ public boolean containsAll(Collection<?> collection) {
     }
 
     /**
-     * @return An object for the given ID, or null if the object was already removed from its box
-     * (and was not cached before).
+     * Gets the target object at the given index.
+     * <p>
+     * {@link ToMany} uses lazy initialization, so on first access this will read the target objects from the database.
      */
     @Override
     public TARGET get(int location) {
@@ -373,6 +420,9 @@ public ListIterator<TARGET> listIterator(int location) {
         return entities.listIterator(location);
     }
 
+    /**
+     * Like {@link #remove(Object)}, but using the location of the target object.
+     */
     @Override
     public synchronized TARGET remove(int location) {
         ensureEntitiesWithTrackingLists();
@@ -381,6 +431,12 @@ public synchronized TARGET remove(int location) {
         return removed;
     }
 
+    /**
+     * Prepares to remove the target object from this relation.
+     * <p>
+     * To apply changes, call {@link #applyChangesToDb()} or put the object with the ToMany. For important details, see
+     * the notes about relations of {@link Box#put(Object)}.
+     */
     @SuppressWarnings("unchecked") // Cast to TARGET: If removed, must be of type TARGET.
     @Override
     public synchronized boolean remove(Object object) {
@@ -392,7 +448,9 @@ public synchronized boolean remove(Object object) {
         return removed;
     }
 
-    /** Removes an object by its entity ID. */
+    /**
+     * Like {@link #remove(Object)}, but using just the ID of the target object.
+     */
     public synchronized TARGET removeById(long id) {
         ensureEntities();
         int size = entities.size();
@@ -482,8 +540,10 @@ public <T> T[] toArray(T[] array) {
     }
 
     /**
-     * Resets the already loaded entities so they will be re-loaded on their next access.
-     * This allows to sync with non-tracked changes (outside of this ToMany object).
+     * Resets the already loaded (cached) objects of this list, so they will be re-loaded when accessing this list
+     * again.
+     * <p>
+     * Use this to sync with changes to this relation or target objects made outside of this ToMany.
      */
     public synchronized void reset() {
         entities = null;
@@ -509,9 +569,9 @@ public int getRemoveCount() {
     }
 
     /**
-     * Sorts the list by the "natural" ObjectBox order for to-many list (by entity ID).
-     * This will be the order when you get the entities fresh (e.g. initially or after calling {@link #reset()}).
-     * Note that non persisted entities (ID is zero) will be put to the end as they are still to get an ID.
+     * Sorts the list by the "natural" ObjectBox order for to-many list (by object ID).
+     * This will be the order when you get the objects fresh (e.g. initially or after calling {@link #reset()}).
+     * Note that non persisted objects (ID is zero) will be put to the end as they are still to get an ID.
      */
     public void sortById() {
         ensureEntities();
@@ -540,23 +600,25 @@ else if (delta > 0)
     }
 
     /**
-     * Applies (persists) tracked changes (added and removed entities) to the target box
-     * and/or updates standalone relations.
-     * Note that this is done automatically when you put the source entity of this to-many relation.
-     * However, if only this to-many relation has changed, it is more efficient to call this method.
+     * Saves changes (added and removed objects) made to this relation to the database. For some important details, see
+     * the notes about relations of {@link Box#put(Object)}.
+     * <p>
+     * Note that this is called already when the object that contains this ToMany is put. However, if only this ToMany
+     * has changed, it is more efficient to just use this method.
      *
-     * @throws IllegalStateException If the source entity of this to-many relation was not previously persisted
+     * @throws IllegalStateException If the object that contains this ToMany has no ID assigned (it must have been put
+     * before).
      */
     public void applyChangesToDb() {
         long id = relationInfo.sourceInfo.getIdGetter().getId(entity);
         if (id == 0) {
             throw new IllegalStateException(
-                    "The source entity was not yet persisted (no ID), use box.put() on it instead");
+                    "The object with the ToMany was not yet persisted (no ID), use box.put() on it instead");
         }
         try {
             ensureBoxes();
         } catch (DbDetachedException e) {
-            throw new IllegalStateException("The source entity was not yet persisted, use box.put() on it instead");
+            throw new IllegalStateException("The object with the ToMany was not yet persisted, use box.put() on it instead");
         }
         if (internalCheckApplyToDbRequired()) {
             // We need a TX because we use two writers and both must use same TX (without: unchecked, SIGSEGV)
@@ -569,10 +631,10 @@ public void applyChangesToDb() {
     }
 
     /**
-     * Returns true if at least one of the entities matches the given filter.
+     * Returns true if at least one of the target objects matches the given filter.
      * <p>
-     * For use with {@link io.objectbox.query.QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
-     * to-many relation entities.
+     * For use with {@link QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
+     * to-many relation objects.
      */
     @Beta
     public boolean hasA(QueryFilter<TARGET> filter) {
@@ -587,10 +649,10 @@ public boolean hasA(QueryFilter<TARGET> filter) {
     }
 
     /**
-     * Returns true if all of the entities match the given filter. Returns false if the list is empty.
+     * Returns true if all of the target objects match the given filter. Returns false if the list is empty.
      * <p>
-     * For use with {@link io.objectbox.query.QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
-     * to-many relation entities.
+     * For use with {@link QueryBuilder#filter(QueryFilter)} inside a {@link QueryFilter} to check
+     * to-many relation objects.
      */
     @Beta
     public boolean hasAll(QueryFilter<TARGET> filter) {
@@ -607,7 +669,7 @@ public boolean hasAll(QueryFilter<TARGET> filter) {
         return true;
     }
 
-    /** Gets an object by its entity ID. */
+    /** Gets an object by its ID. */
     @Beta
     public TARGET getById(long id) {
         ensureEntities();
@@ -622,7 +684,7 @@ public TARGET getById(long id) {
         return null;
     }
 
-    /** Gets the index of the object with the given entity ID. */
+    /** Gets the index of the object with the given ID. */
     @Beta
     public int indexOfId(long id) {
         ensureEntities();
@@ -641,7 +703,7 @@ public int indexOfId(long id) {
 
     /**
      * Returns true if there are pending changes for the DB.
-     * Changes will be automatically persisted once the owning entity is put, or an explicit call to
+     * Changes will be automatically persisted once the object with the ToMany is put, or an explicit call to
      * {@link #applyChangesToDb()} is made.
      */
     public boolean hasPendingDbChanges() {
@@ -656,7 +718,7 @@ public boolean hasPendingDbChanges() {
 
     /**
      * For internal use only; do not use in your app.
-     * Called after relation source entity is put (so we have its ID).
+     * Called after relation source object is put (so we have its ID).
      * Prepares data for {@link #internalApplyToDb(Cursor, Cursor)}
      */
     @Internal
@@ -680,7 +742,7 @@ public boolean internalCheckApplyToDbRequired() {
             // Relation based on Backlink
             long entityId = relationInfo.sourceInfo.getIdGetter().getId(entity);
             if (entityId == 0) {
-                throw new IllegalStateException("Source entity has no ID (should have been put before)");
+                throw new IllegalStateException("Object with the ToMany has no ID (should have been put before)");
             }
             IdGetter<TARGET> idGetter = relationInfo.targetInfo.getIdGetter();
             Map<TARGET, Boolean> setAdded = this.entitiesAdded;
@@ -694,9 +756,20 @@ public boolean internalCheckApplyToDbRequired() {
         }
     }
 
+    /**
+     * Modifies the {@link Backlink linked} ToMany relation of added or removed target objects and schedules put by
+     * {@link #internalApplyToDb} for them.
+     * <p>
+     * If {@link #setRemoveFromTargetBox} is true, removed target objects are scheduled for removal instead of just
+     * updating their ToMany relation.
+     * <p>
+     * If target objects are new, schedules a put if they were added, but never if they were removed from this relation.
+     *
+     * @return Whether there are any target objects to put or remove.
+     */
     private boolean prepareToManyBacklinkEntitiesForDb(long entityId, IdGetter<TARGET> idGetter,
-            @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
-        ToManyGetter<TARGET> backlinkToManyGetter = relationInfo.backlinkToManyGetter;
+                                                       @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
+        ToManyGetter<TARGET, Object> backlinkToManyGetter = relationInfo.backlinkToManyGetter;
 
         synchronized (this) {
             if (setAdded != null && !setAdded.isEmpty()) {
@@ -738,9 +811,12 @@ private boolean prepareToManyBacklinkEntitiesForDb(long entityId, IdGetter<TARGE
         }
     }
 
+    /**
+     * Like {@link #prepareToManyBacklinkEntitiesForDb} but for the linked ToOne relation.
+     */
     private boolean prepareToOneBacklinkEntitiesForDb(long entityId, IdGetter<TARGET> idGetter,
-            @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
-        ToOneGetter<TARGET> backlinkToOneGetter = relationInfo.backlinkToOneGetter;
+                                                      @Nullable Map<TARGET, Boolean> setAdded, @Nullable Map<TARGET, Boolean> setRemoved) {
+        ToOneGetter<TARGET, Object> backlinkToOneGetter = relationInfo.backlinkToOneGetter;
 
         synchronized (this) {
             if (setAdded != null && !setAdded.isEmpty()) {
@@ -840,7 +916,7 @@ public void internalApplyToDb(Cursor<?> sourceCursor, Cursor<TARGET> targetCurso
         if (isStandaloneRelation) {
             long entityId = relationInfo.sourceInfo.getIdGetter().getId(entity);
             if (entityId == 0) {
-                throw new IllegalStateException("Source entity has no ID (should have been put before)");
+                throw new IllegalStateException("Object with the ToMany has no ID (should have been put before)");
             }
 
             if (removedStandalone != null) {
@@ -883,7 +959,7 @@ private void addStandaloneRelations(Cursor<?> cursor, long sourceEntityId, TARGE
             long targetId = targetIdGetter.getId(added[i]);
             if (targetId == 0) {
                 // Paranoia
-                throw new IllegalStateException("Target entity has no ID (should have been put before)");
+                throw new IllegalStateException("Target object has no ID (should have been put before)");
             }
             targetIds[i] = targetId;
         }
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java b/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java
index 44b13c6f..254c4537 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/ToOne.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -24,22 +24,64 @@
 import io.objectbox.Box;
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
+import io.objectbox.annotation.Backlink;
+import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.apihint.Internal;
 import io.objectbox.exception.DbDetachedException;
 import io.objectbox.internal.ReflectionCache;
 
 /**
- * Manages a to-one relation: resolves the target object, keeps the target Id in sync, etc.
- * A to-relation is unidirectional: it points from the source entity to the target entity.
- * The target is referenced by its ID, which is persisted in the source entity.
+ * A to-one relation of an entity that references one object of a {@link TARGET} entity.
  * <p>
- * If there is a {@link ToMany} relation linking back to this to-one relation (@Backlink),
- * the ToMany object will not be notified/updated about persisted changes here.
- * Call {@link ToMany#reset()} so it will update when next accessed.
+ * Example:
+ * <pre>{@code
+ * // Java
+ * @Entity
+ * public class Order {
+ *     private ToOne<Customer> customer;
+ * }
+ *
+ * // Kotlin
+ * @Entity
+ * data class Order() {
+ *     lateinit var customer: ToOne<Customer>
+ * }
+ * }</pre>
+ * <p>
+ * Uses lazy initialization. The target object ({@link #getTarget()}) is only read from the database when it is first
+ * accessed.
+ * <p>
+ * Common usage:
+ * <ul>
+ * <li>Set the target object with {@link #setTarget} to create a relation.
+ *     When the object with the ToOne is put, if the target object is new (its ID is 0), it will be put as well.
+ *     Otherwise, only the target ID in the database is updated.
+ * <li>{@link #setTargetId} of the target object to create a relation.
+ * <li>{@link #setTarget} with {@code null} or {@link #setTargetId} to {@code 0} to remove the relation.
+ * </ul>
+ * <p>
+ * Then, to persist the changes {@link Box#put} the object with the ToOne.
+ * <pre>{@code
+ * // Example 1: create a relation
+ * order.getCustomer().setTarget(customer);
+ * // or order.getCustomer().setTargetId(customerId);
+ * store.boxFor(Order.class).put(order);
+ *
+ * // Example 2: remove the relation
+ * order.getCustomer().setTarget(null);
+ * // or order.getCustomer().setTargetId(0);
+ * store.boxFor(Order.class).put(order);
+ * }</pre>
+ * <p>
+ * The target object is referenced by its ID.
+ * This target ID ({@link #getTargetId()}) is persisted as part of the object with the ToOne in a special
+ * property created for each ToOne (named like "customerId").
+ * <p>
+ * To get all objects with a ToOne that reference a target object, see {@link Backlink}.
+ *
+ * @param <TARGET> target object type ({@link Entity @Entity} class).
  */
-// TODO add more tests
 // TODO not exactly thread safe
-// TODO enforce not-null (not zero) checks on the target setters once we use some not-null annotation
 public class ToOne<TARGET> implements Serializable {
     private static final long serialVersionUID = 5092547044335989281L;
 
@@ -85,7 +127,9 @@ public ToOne(Object sourceEntity, RelationInfo<?, TARGET> relationInfo) {
     }
 
     /**
-     * @return The target entity of the to-one relation.
+      * Returns the target object or {@code null} if there is none.
+     * <p>
+     * {@link ToOne} uses lazy initialization, so on first access this will read the target object from the database.
      */
     public TARGET getTarget() {
         return getTarget(getTargetId());
@@ -150,10 +194,11 @@ public boolean isNull() {
     }
 
     /**
-     * Sets or clears the target ID in the source entity. Pass 0 to clear.
+     * Prepares to set the target of this relation to the object with the given ID. Pass {@code 0} to remove an existing
+     * one.
      * <p>
-     * Put the source entity to persist changes.
-     * If the ID is not 0 creates a relation to the target entity with this ID, otherwise dissolves it.
+     * To apply changes, put the object with the ToOne. For important details, see the notes about relations of
+     * {@link Box#put(Object)}.
      *
      * @see #setTarget
      */
@@ -181,10 +226,10 @@ void setAndUpdateTargetId(long targetId) {
     }
 
     /**
-     * Sets or clears the target entity and ID in the source entity. Pass null to clear.
+     * Prepares to set the target object of this relation. Pass {@code null} to remove an existing one.
      * <p>
-     * Put the source entity to persist changes.
-     * If the target entity was not put yet (its ID is 0), it will be stored when the source entity is put.
+     * To apply changes, put the object with the ToOne. For important details, see the notes about relations of
+     * {@link Box#put(Object)}.
      *
      * @see #setTargetId
      */
diff --git a/objectbox-java/src/main/java/io/objectbox/relation/package-info.java b/objectbox-java/src/main/java/io/objectbox/relation/package-info.java
index bc168d06..fa27060c 100644
--- a/objectbox-java/src/main/java/io/objectbox/relation/package-info.java
+++ b/objectbox-java/src/main/java/io/objectbox/relation/package-info.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,7 @@
 
 /**
  * Classes to manage {@link io.objectbox.relation.ToOne} and {@link io.objectbox.relation.ToMany}
- * relations between entities.
+ * relations between Entities.
  * <p>
  * For more details look at the documentation of individual classes and
  * <a href="https://docs.objectbox.io/relations">docs.objectbox.io/relations</a>.
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java b/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java
new file mode 100644
index 00000000..11270a73
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/ConnectivityMonitor.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import javax.annotation.Nullable;
+
+/**
+ * Used by {@link SyncClient} to observe connectivity changes.
+ * <p>
+ * Implementations are provided by a {@link io.objectbox.sync.internal.Platform platform}.
+ */
+public abstract class ConnectivityMonitor {
+
+    @Nullable
+    private SyncClient syncClient;
+
+    void setObserver(SyncClient syncClient) {
+        //noinspection ConstantConditions Annotations do not enforce non-null.
+        if (syncClient == null) {
+            throw new IllegalArgumentException("Sync client must not be null");
+        }
+        this.syncClient = syncClient;
+        onObserverSet();
+    }
+
+    void removeObserver() {
+        this.syncClient = null;
+        onObserverRemoved();
+    }
+
+    /**
+     * Called right after the observer was set.
+     */
+    public void onObserverSet() {
+    }
+
+    /**
+     * Called right after the observer was removed.
+     */
+    public void onObserverRemoved() {
+    }
+
+    /**
+     * Notifies the observer that a connection is available.
+     * Implementers should call this once a working network connection is available.
+     */
+    public final void notifyConnectionAvailable() {
+        SyncClient syncClient = this.syncClient;
+        if (syncClient != null) {
+            syncClient.notifyConnectionAvailable();
+        }
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/Credentials.java b/objectbox-java/src/main/java/io/objectbox/sync/Credentials.java
new file mode 100644
index 00000000..b06c6460
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/Credentials.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Credentials consist of a type and the credentials data to perform authentication checks.
+ * The data is either provided as plain-bytes, or as a list of strings.
+ * Credentials can be used from the client and server side.
+ * This depends on the type however:
+ * for example, shared secrets are configured at both sides, but username/password is only provided at the client.
+ */
+@SuppressWarnings("unused")
+public final class Credentials extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static Credentials getRootAsCredentials(ByteBuffer _bb) { return getRootAsCredentials(_bb, new Credentials()); }
+  public static Credentials getRootAsCredentials(ByteBuffer _bb, Credentials obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public Credentials __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public long type() { int o = __offset(4); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Credentials provided by plain bytes.
+   * This is used for shared secrets (client & server).
+   */
+  public int bytes(int j) { int o = __offset(6); return o != 0 ? bb.get(__vector(o) + j * 1) & 0xFF : 0; }
+  public int bytesLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public ByteVector bytesVector() { return bytesVector(new ByteVector()); }
+  public ByteVector bytesVector(ByteVector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer bytesAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+  public ByteBuffer bytesInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
+  /**
+   * Credentials provided by a string array.
+   * For username/password (client-only), provide the username in strings[0] and the password in strings[1].
+   * For GoogleAuth, you can provide a list of accepted IDs (server-only).
+   */
+  public String strings(int j) { int o = __offset(8); return o != 0 ? __string(__vector(o) + j * 4) : null; }
+  public int stringsLength() { int o = __offset(8); return o != 0 ? __vector_len(o) : 0; }
+  public StringVector stringsVector() { return stringsVector(new StringVector()); }
+  public StringVector stringsVector(StringVector obj) { int o = __offset(8); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+
+  public static int createCredentials(FlatBufferBuilder builder,
+      long type,
+      int bytesOffset,
+      int stringsOffset) {
+    builder.startTable(3);
+    Credentials.addStrings(builder, stringsOffset);
+    Credentials.addBytes(builder, bytesOffset);
+    Credentials.addType(builder, type);
+    return Credentials.endCredentials(builder);
+  }
+
+  public static void startCredentials(FlatBufferBuilder builder) { builder.startTable(3); }
+  public static void addType(FlatBufferBuilder builder, long type) { builder.addInt(0, (int) type, (int) 0L); }
+  public static void addBytes(FlatBufferBuilder builder, int bytesOffset) { builder.addOffset(1, bytesOffset, 0); }
+  public static int createBytesVector(FlatBufferBuilder builder, byte[] data) { return builder.createByteVector(data); }
+  public static int createBytesVector(FlatBufferBuilder builder, ByteBuffer data) { return builder.createByteVector(data); }
+  public static void startBytesVector(FlatBufferBuilder builder, int numElems) { builder.startVector(1, numElems, 1); }
+  public static void addStrings(FlatBufferBuilder builder, int stringsOffset) { builder.addOffset(2, stringsOffset, 0); }
+  public static int createStringsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startStringsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endCredentials(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public Credentials get(int j) { return get(new Credentials(), j); }
+    public Credentials get(Credentials obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/CredentialsType.java b/objectbox-java/src/main/java/io/objectbox/sync/CredentialsType.java
new file mode 100644
index 00000000..0b4cce7e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/CredentialsType.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync;
+
+/**
+ * Credentials types for login at a sync server.
+ */
+@SuppressWarnings("unused")
+public final class CredentialsType {
+  private CredentialsType() { }
+  /**
+   * Used to indicate an uninitialized variable. Should never be sent/received in a message.
+   */
+  public static final int Invalid = 0;
+  /**
+   * No credentials required; do not use for public/production servers.
+   * This is useful for testing and during development.
+   */
+  public static final int None = 1;
+  /**
+   * Deprecated, replaced by SHARED_SECRET_SIPPED
+   */
+  public static final int SharedSecret = 2;
+  /**
+   * Google Auth ID token
+   */
+  public static final int GoogleAuth = 3;
+  /**
+   * Use shared secret to create a SipHash and make attacks harder than just copy&paste.
+   * (At some point we may want to switch to crypto & challenge/response.)
+   */
+  public static final int SharedSecretSipped = 4;
+  /**
+   * Use ObjectBox Admin users for Sync authentication.
+   */
+  public static final int ObxAdminUser = 5;
+  /**
+   * Generic credential type suitable for ObjectBox admin (and possibly others in the future)
+   */
+  public static final int UserPassword = 6;
+  /**
+   * JSON Web Token (JWT): an ID token that typically provides identity information about the authenticated user.
+   */
+  public static final int JwtId = 7;
+  /**
+   * JSON Web Token (JWT): an access token that is used to access resources.
+   */
+  public static final int JwtAccess = 8;
+  /**
+   * JSON Web Token (JWT): a refresh token that is used to obtain a new access token.
+   */
+  public static final int JwtRefresh = 9;
+  /**
+   * JSON Web Token (JWT): a token that is neither an ID, access, nor refresh token.
+   */
+  public static final int JwtCustom = 10;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/InternalSyncAccess.java b/objectbox-java/src/main/java/io/objectbox/sync/InternalSyncAccess.java
new file mode 100644
index 00000000..e58f7f8e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/InternalSyncAccess.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Internal sync access for ObjectBox platform integrations, e.g. platform-specific mesh networks.
+ * This class is not part of the public API and may change without notice.
+ */
+@Internal
+public final class InternalSyncAccess {
+
+    /**
+     * Creates a mesh sync configuration. See the {@link MeshConfig} setters for details on each
+     * option.
+     *
+     * @param meshId The mesh network identifier (required); nodes with different IDs ignore each
+     * other.
+     */
+    public static MeshConfig createMeshConfig(String meshId) {
+        return new MeshConfig(meshId);
+    }
+
+    /**
+     * Adds a platform-specific native network (transport) to a mesh config.
+     *
+     * @param networkInternalHandle an internal handle to a native mesh network created by a
+     * platform library.
+     */
+    public static void addNetworkInternalHandle(MeshConfig config, long networkInternalHandle) {
+        config.networkInternalHandles.add(networkInternalHandle);
+    }
+
+    private InternalSyncAccess() {
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshConfig.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshConfig.java
new file mode 100644
index 00000000..59795c51
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshConfig.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * Configuration of a peer-to-peer mesh sync.
+ * <p>
+ * A mesh sync enables peer-to-peer (P2P) synchronization between sync clients without a central
+ * server. Pass an instance to {@link SyncBuilder#mesh(MeshConfig)} to attach a mesh sync to the
+ * client; it starts and stops together with the client. Query the running mesh via
+ * {@link SyncClient#getMesh()}.
+ * <p>
+ * A mesh requires at least one platform-specific network (transport); networks are registered by
+ * ObjectBox platform libraries (e.g. for Android), which also create this configuration. Thus, this
+ * class can not be created directly; see the documentation of the platform library for how to
+ * obtain a mesh configuration.
+ * <p>
+ * Only the mesh ID is required; all other values are optional and fall back to the defaults of the
+ * ObjectBox native library when not set. The values are read once when the sync client is created,
+ * which is also when the native library validates them.
+ */
+@Experimental
+public final class MeshConfig {
+
+    final String meshId;
+    @Nullable Integer maxConnectionCount;
+    @Nullable Integer backoffMillis;
+    @Nullable Integer evictionBackoffMillis;
+    @Nullable Integer requestTimeoutMillis;
+    @Nullable Integer advertisingDelayMillis;
+    @Nullable Integer advertisingRetryMillis;
+    @Nullable Integer advertisingRetryMaxMillis;
+    @Nullable Integer connectDelayMillis;
+    @Nullable Integer initialDiscoveryDurationSeconds;
+    @Nullable Integer discoveryDurationSeconds;
+    @Nullable Integer discoveryPauseSeconds;
+    @Nullable Integer discoveryPauseJitterSeconds;
+    @Nullable Integer txLogBatchSizeKb;
+    @Nullable Integer txLogBatchMaxCount;
+
+    /**
+     * Handles to platform-specific native networks (transports) to register with the mesh sync,
+     * added via {@link InternalSyncAccess#addNetworkInternalHandle(MeshConfig, long)}.
+     */
+    final List<Long> networkInternalHandles = new ArrayList<>();
+
+    /**
+     * Use {@link InternalSyncAccess#createMeshConfig(String)} instead.
+     *
+     * @param meshId The mesh network identifier (required); nodes with different IDs ignore each
+     * other.
+     */
+    MeshConfig(String meshId) {
+        if (meshId == null || meshId.isEmpty()) {
+            throw new IllegalArgumentException("meshId must not be null or empty.");
+        }
+        this.meshId = meshId;
+    }
+
+    /**
+     * Maximum number of simultaneous connections a peer can have to other peers (default: 3).
+     * <p>
+     * The default of 3 already provides mesh resilience through alternative paths. 4 may give
+     * better fault tolerance, but at the cost of more radio activity. Values above 4 are not
+     * recommended. 2 is typically not recommended unless you run into severe radio limitations. 1
+     * would be a rare special case if you only want to create pairs, not a mesh.
+     */
+    public MeshConfig maxConnectionCount(int maxConnectionCount) {
+        this.maxConnectionCount = maxConnectionCount;
+        return this;
+    }
+
+    /**
+     * Backoff time in milliseconds before retrying a failed connection (default: 10000).
+     */
+    public MeshConfig backoffMillis(int backoffMillis) {
+        this.backoffMillis = backoffMillis;
+        return this;
+    }
+
+    /**
+     * Backoff time in milliseconds between peer evictions (default: 30000).
+     * <p>
+     * When an incoming peer has 0 connections, but this peer is at
+     * {@link #maxConnectionCount(int)}, this peer ends a connection to an existing peer, it
+     * "evicts" that peer, to make room. This backoff prevents frequent evictions.
+     */
+    public MeshConfig evictionBackoffMillis(int evictionBackoffMillis) {
+        this.evictionBackoffMillis = evictionBackoffMillis;
+        return this;
+    }
+
+    /**
+     * Timeout in milliseconds for a TX request from a peer before retrying from another (default:
+     * 5000).
+     */
+    public MeshConfig requestTimeoutMillis(int requestTimeoutMillis) {
+        this.requestTimeoutMillis = requestTimeoutMillis;
+        return this;
+    }
+
+    /**
+     * Delay in milliseconds before advertising starts after the mesh sync starts (default: 2000).
+     * <p>
+     * Discovery always starts immediately; advertising is delayed to "stretch out" radio activity.
+     */
+    public MeshConfig advertisingDelayMillis(int advertisingDelayMillis) {
+        this.advertisingDelayMillis = advertisingDelayMillis;
+        return this;
+    }
+
+    /**
+     * Base delay in milliseconds before retrying advertising after a network failed to start it
+     * (default: 5000).
+     * <p>
+     * A network may fail to start advertising (e.g. missing permissions); advertising is then
+     * retried with exponential backoff (doubling up to {@link #advertisingRetryMaxMillis(int)}),
+     * because the required permissions may be granted later at runtime. Must be positive.
+     */
+    public MeshConfig advertisingRetryMillis(int advertisingRetryMillis) {
+        this.advertisingRetryMillis = advertisingRetryMillis;
+        return this;
+    }
+
+    /**
+     * Upper bound in milliseconds for the advertising retry backoff (default: 60000).
+     * <p>
+     * Must be greater than or equal to {@link #advertisingRetryMillis(int)}.
+     */
+    public MeshConfig advertisingRetryMaxMillis(int advertisingRetryMaxMillis) {
+        this.advertisingRetryMaxMillis = advertisingRetryMaxMillis;
+        return this;
+    }
+
+    /**
+     * Minimum delay in milliseconds between two outgoing connection attempts (default: 1000).
+     */
+    public MeshConfig connectDelayMillis(int connectDelayMillis) {
+        this.connectDelayMillis = connectDelayMillis;
+        return this;
+    }
+
+    /**
+     * Duration in seconds of the initial discovery phase (default: 30; 0 means never stop by
+     * time).
+     *
+     * @see #discoveryDurationSeconds(int)
+     */
+    public MeshConfig initialDiscoveryDurationSeconds(int initialDiscoveryDurationSeconds) {
+        this.initialDiscoveryDurationSeconds = initialDiscoveryDurationSeconds;
+        return this;
+    }
+
+    /**
+     * Duration in seconds of a standard (non-initial) discovery phase (default: 15; 0 means never
+     * stop by time).
+     *
+     * @see #initialDiscoveryDurationSeconds(int)
+     */
+    public MeshConfig discoveryDurationSeconds(int discoveryDurationSeconds) {
+        this.discoveryDurationSeconds = discoveryDurationSeconds;
+        return this;
+    }
+
+    /**
+     * Pause in seconds between two discovery phases (default: 45).
+     */
+    public MeshConfig discoveryPauseSeconds(int discoveryPauseSeconds) {
+        this.discoveryPauseSeconds = discoveryPauseSeconds;
+        return this;
+    }
+
+    /**
+     * Random +/- jitter in seconds applied to the discovery pause (default: 15; must be &lt;=
+     * pause). 0 disables jitter.
+     */
+    public MeshConfig discoveryPauseJitterSeconds(int discoveryPauseJitterSeconds) {
+        this.discoveryPauseJitterSeconds = discoveryPauseJitterSeconds;
+        return this;
+    }
+
+    /**
+     * Soft cap in KB for the total TX log payload batched into a single TxLogData message (default:
+     * 100).
+     */
+    public MeshConfig txLogBatchSizeKb(int txLogBatchSizeKb) {
+        this.txLogBatchSizeKb = txLogBatchSizeKb;
+        return this;
+    }
+
+    /**
+     * Maximum number of TX logs to batch into a single TxLogData message (default: 1000). Must be
+     * in the range (0, 100000].
+     */
+    public MeshConfig txLogBatchMaxCount(int txLogBatchMaxCount) {
+        this.txLogBatchMaxCount = txLogBatchMaxCount;
+        return this;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshState.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshState.java
new file mode 100644
index 00000000..9f1e16e6
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshState.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * State of a {@link MeshSync} as returned by {@link MeshSync#getState()}.
+ */
+@Experimental
+public enum MeshState {
+
+    /**
+     * State is unknown, e.g. the native API reported a state that's not recognized yet.
+     */
+    UNKNOWN(0),
+
+    /**
+     * Created, but not started yet.
+     */
+    CREATED(1),
+
+    /**
+     * Discovery is active (not enough peers connected yet).
+     */
+    DISCOVERING(2),
+
+    /**
+     * Fully connected: the maximum number of peers (see {@link MeshConfig#maxConnectionCount(int)})
+     * is connected.
+     */
+    FULLY_CONNECTED(3),
+
+    /**
+     * Stopped.
+     */
+    STOPPED(4),
+
+    /**
+     * Stopped and native resources have been released.
+     * <p>
+     * Note that checks in the Java API should prevent this state from ever getting returned.
+     */
+    DEAD(5);
+
+    public final int id;
+
+    MeshState(int id) {
+        this.id = id;
+    }
+
+    public static MeshState fromId(int id) {
+        for (MeshState value : values()) {
+            if (value.id == id) return value;
+        }
+        return UNKNOWN;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshStats.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshStats.java
new file mode 100644
index 00000000..013cc45f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshStats.java
@@ -0,0 +1,123 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * Mesh sync statistics counters, useful for testing and diagnostics.
+ * <p>
+ * Read a counter value with {@link MeshSync#getStats(MeshStats)}.
+ */
+@Experimental
+public enum MeshStats {
+
+    /**
+     * Number of peers discovered.
+     */
+    PEERS_DISCOVERED(1),
+
+    /**
+     * Number of peers connected.
+     */
+    PEERS_CONNECTED(2),
+
+    /**
+     * Number of peers disconnected.
+     */
+    PEERS_DISCONNECTED(3),
+
+    /**
+     * Number of peer connection attempts that failed.
+     */
+    PEER_CONNECTIONS_FAILED(4),
+
+    /**
+     * Number of peers lost (no longer available after discovery).
+     */
+    PEERS_LOST(5),
+
+    /**
+     * Number of messages received.
+     */
+    MESSAGES_RECEIVED(6),
+
+    /**
+     * Number of messages sent.
+     */
+    MESSAGES_SENT(7),
+
+    /**
+     * Number of TX IDs announced.
+     */
+    TX_IDS_ANNOUNCED(8),
+
+    /**
+     * Number of TX IDs requested (sent in TxLogRequest messages).
+     */
+    TX_IDS_REQUESTED(9),
+
+    /**
+     * Number of TX IDs received.
+     */
+    TX_IDS_RECEIVED(10),
+
+    /**
+     * Number of TX logs sent (in TxLogData messages).
+     */
+    TX_LOGS_SENT(11),
+
+    /**
+     * Number of TX logs received and stored (from TxLogData messages).
+     */
+    TX_LOGS_RECEIVED(12),
+
+    /**
+     * Number of TX logs applied to the local database.
+     */
+    TX_LOGS_APPLIED(13),
+
+    /**
+     * Number of protocol errors.
+     */
+    PROTOCOL_ERRORS(14),
+
+    /**
+     * Number of general errors.
+     */
+    GENERAL_ERRORS(15),
+
+    /**
+     * Number of peers evicted to make room for newcomers.
+     */
+    PEERS_EVICTED(16),
+
+    /**
+     * Number of discoveries of our own peer ID prefix that were ignored.
+     */
+    SELF_DISCOVERIES_IGNORED(17);
+
+    /**
+     * The counter type ID passed to the native API.
+     */
+    final int id;
+
+    MeshStats(int id) {
+        this.id = id;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/MeshSync.java b/objectbox-java/src/main/java/io/objectbox/sync/MeshSync.java
new file mode 100644
index 00000000..1e84e424
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/MeshSync.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * A running peer-to-peer mesh sync, obtained via {@link SyncClient#getMesh()}.
+ * <p>
+ * Configure a mesh via a {@link MeshConfig} passed to {@link SyncBuilder#mesh(MeshConfig)}. The mesh is owned by the
+ * sync client and starts and stops together with it. Once the owning sync client is closed, this object is no longer
+ * valid and any access throws an {@link IllegalStateException}.
+ */
+@Experimental
+public final class MeshSync {
+
+    /**
+     * The native mesh is owned by the sync client; this handle is reset by {@link SyncClientImpl#close()} so later
+     * access throws instead of using a dangling pointer.
+     */
+    private volatile long handle;
+
+    MeshSync(long handle) {
+        this.handle = handle;
+    }
+
+    private long getHandle() {
+        long handle = this.handle;
+        if (handle == 0) {
+            throw new IllegalStateException("MeshSync is no longer valid (the owning SyncClient was closed)");
+        }
+        return handle;
+    }
+
+    /**
+     * Invalidates this mesh; called by the owning sync client when it is closed.
+     */
+    void invalidate() {
+        handle = 0;
+    }
+
+    /**
+     * Gets the current state of this mesh sync.
+     */
+    public MeshState getState() {
+        return MeshState.fromId(nativeGetState(getHandle()));
+    }
+
+    /**
+     * Gets a human-readable string for the current mesh sync state (e.g. "Discovering").
+     */
+    public String getStateString() {
+        return nativeGetStateString(getHandle());
+    }
+
+    /**
+     * Returns the number of currently connected peers.
+     */
+    public long getConnectedPeerCount() {
+        return nativeGetConnectedPeerCount(getHandle());
+    }
+
+    /**
+     * Gets a mesh sync statistics counter value, see {@link MeshStats}.
+     */
+    public long getStats(MeshStats counter) {
+        return nativeGetStats(getHandle(), counter.id);
+    }
+
+    /**
+     * Requests an immediate retry of the network radios: advertising (bypassing the current retry
+     * backoff) and discovery (restarting the current phase).
+     * <p>
+     * Call this when conditions that may have prevented the radios from starting have changed, e.g.
+     * the user just granted the required permissions. Thread-safe; the actual retry happens on the
+     * mesh sync thread shortly after.
+     */
+    public void retryNetworks() {
+        nativeRetryNetworks(getHandle());
+    }
+
+    /**
+     * Returns the current {@link MeshState} value.
+     */
+    private static native int nativeGetState(long handle);
+
+    private static native String nativeGetStateString(long handle);
+
+    private static native long nativeGetConnectedPeerCount(long handle);
+
+    private static native void nativeRetryNetworks(long handle);
+
+    /**
+     * @param counterType One of the {@link MeshStats} IDs.
+     */
+    private static native long nativeGetStats(long handle, int counterType);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java
new file mode 100644
index 00000000..96dbba31
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/ObjectsMessageBuilder.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+/**
+ * @see SyncClient#startObjectsMessage
+ */
+public interface ObjectsMessageBuilder {
+
+    ObjectsMessageBuilder addString(long optionalId, String value);
+
+    ObjectsMessageBuilder addBytes(long optionalId, byte[] value, boolean isFlatBuffers);
+
+    /**
+     * Sends the message, returns true if successful.
+     */
+    boolean send();
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/Sync.java b/objectbox-java/src/main/java/io/objectbox/sync/Sync.java
new file mode 100644
index 00000000..aaf421a2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/Sync.java
@@ -0,0 +1,159 @@
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.util.Arrays;
+
+import io.objectbox.BoxStore;
+import io.objectbox.BoxStoreBuilder;
+import io.objectbox.sync.server.SyncServer;
+import io.objectbox.sync.server.SyncServerBuilder;
+
+/**
+ * <a href="https://objectbox.io/sync/">ObjectBox Sync</a> makes data available on other devices.
+ * <p>
+ * Use the static methods to build a Sync client or embedded server.
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+public final class Sync {
+
+    /**
+     * Returns true if the included native (JNI) ObjectBox library supports Sync.
+     */
+    public static boolean isAvailable() {
+        return BoxStore.isSyncAvailable();
+    }
+
+    /**
+     * Returns true if the included native (JNI) ObjectBox library supports Sync server.
+     */
+    public static boolean isServerAvailable() {
+        return BoxStore.isSyncServerAvailable();
+    }
+
+    /**
+     * Returns true if the included native (JNI) ObjectBox library supports Sync hybrids (server and client).
+     */
+    public static boolean isHybridAvailable() {
+        return isAvailable() && isServerAvailable();
+    }
+
+    /**
+     * Starts building a {@link SyncClient} for the given {@link BoxStore}.
+     * <p>
+     * This does not initiate any connection attempts yet: call {@link SyncBuilder#buildAndStart()} to do so. Before,
+     * you must configure the server URL via {@link SyncBuilder#url(String)} and add credentials via
+     * {@link SyncBuilder#credentials(SyncCredentials)}.
+     * <p>
+     * By default, a Sync client automatically receives updates from the server once login succeeded. To configure this
+     * differently, call {@link SyncBuilder#requestUpdatesMode(SyncBuilder.RequestUpdatesMode)} with the wanted mode.
+     *
+     * @param boxStore The {@link BoxStore} the client should use.
+     * @return a builder to configure the Sync client
+     */
+    public static SyncBuilder client(BoxStore boxStore) {
+        return new SyncBuilder(boxStore);
+    }
+
+    /**
+     * Starts building a {@link SyncClient}. Once done, complete with {@link SyncBuilder#build() build()}.
+     *
+     * @param boxStore The {@link BoxStore} the client should use.
+     * @param url The URL of the Sync server on which the Sync protocol is exposed. This is typically a WebSockets URL
+     * starting with {@code ws://} or {@code wss://} (for encrypted connections), for example
+     * {@code ws://127.0.0.1:9999}.
+     * @param credentials {@link SyncCredentials} to authenticate with the server.
+     * @deprecated Use {@link #client(BoxStore)}, {@link SyncBuilder#url(String)} and
+     * {@link SyncBuilder#credentials(SyncCredentials)} instead.
+     */
+    @Deprecated
+    public static SyncBuilder client(BoxStore boxStore, String url, SyncCredentials credentials) {
+        return client(boxStore)
+                .url(url)
+                .credentials(credentials);
+    }
+
+    /**
+     * Like {@link #client(BoxStore, String, SyncCredentials)}, but supports passing a set of authentication methods.
+     *
+     * @param multipleCredentials An array of {@link SyncCredentials} to be used to authenticate with the server.
+     * @deprecated Use {@link #client(BoxStore)}, {@link SyncBuilder#url(String)} and
+     * {@link SyncBuilder#credentials(SyncCredentials)} instead.
+     */
+    @Deprecated
+    public static SyncBuilder client(BoxStore boxStore, String url, SyncCredentials[] multipleCredentials) {
+        SyncBuilder builder = client(boxStore).url(url);
+        //noinspection ConstantValue
+        if (multipleCredentials != null) {
+            builder.credentials(Arrays.asList(multipleCredentials));
+        }
+        return builder;
+    }
+
+    /**
+     * Starts building a {@link SyncServer}. Once done, complete with {@link SyncServerBuilder#build() build()}.
+     * <p>
+     * Note: when also using Admin, make sure it is started before the server.
+     *
+     * @param boxStore The {@link BoxStore} the server should use.
+     * @param url The URL of the Sync server on which the Sync protocol is exposed. This is typically a WebSockets URL
+     * starting with {@code ws://} or {@code wss://} (for encrypted connections), for example
+     * {@code ws://0.0.0.0:9999}.
+     * @param authenticatorCredentials An authentication method available to Sync clients and peers. Additional
+     * authenticator credentials can be supplied using the returned builder. For the embedded server, currently only
+     * {@link SyncCredentials#sharedSecret}, any JWT method like {@link SyncCredentials#jwtIdTokenServer()} as well as
+     * {@link SyncCredentials#none} are supported.
+     */
+    public static SyncServerBuilder server(BoxStore boxStore, String url, SyncCredentials authenticatorCredentials) {
+        return new SyncServerBuilder(boxStore, url, authenticatorCredentials);
+    }
+
+    /**
+     * Like {@link #server(BoxStore, String, SyncCredentials)}, but supports passing a set of authentication methods
+     * for clients and peers.
+     */
+    public static SyncServerBuilder server(BoxStore boxStore, String url, SyncCredentials[] multipleAuthenticatorCredentials) {
+        return new SyncServerBuilder(boxStore, url, multipleAuthenticatorCredentials);
+    }
+
+    /**
+     * Starts building a {@link SyncHybrid}, a client/server hybrid typically used for embedded cluster setups.
+     * <p>
+     * Unlike {@link #client(BoxStore, String, SyncCredentials)} and {@link #server(BoxStore, String, SyncCredentials)},
+     * the client Store is not built before. Instead, a Store builder must be passed. The client and server Store will
+     * be built internally when calling this method.
+     * <p>
+     * To configure client and server use the methods on {@link SyncHybridBuilder}.
+     *
+     * @param storeBuilder The {@link BoxStoreBuilder} to use for building the client store.
+     * @param url The URL of the Sync server on which the Sync protocol is exposed. This is typically a WebSockets URL
+     * starting with {@code ws://} or {@code wss://} (for encrypted connections), for example
+     * {@code ws://0.0.0.0:9999}.
+     * @param authenticatorCredentials An authentication method available to Sync clients and peers. The client of the
+     * hybrid is pre-configured with them. Additional credentials can be supplied using the client and server builder of
+     * the returned builder. For the embedded server, currently only {@link SyncCredentials#sharedSecret}, any JWT
+     * method like {@link SyncCredentials#jwtIdTokenServer()} as well as {@link SyncCredentials#none} are supported.
+     * @return An instance of {@link SyncHybridBuilder}.
+     */
+    public static SyncHybridBuilder hybrid(BoxStoreBuilder storeBuilder, String url,
+                                           SyncCredentials authenticatorCredentials) {
+        return new SyncHybridBuilder(storeBuilder, url, authenticatorCredentials);
+    }
+
+    private Sync() {
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java
new file mode 100644
index 00000000..107af027
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncBuilder.java
@@ -0,0 +1,341 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.TreeMap;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.internal.NativeLibraryUtils;
+import io.objectbox.sync.internal.Platform;
+import io.objectbox.sync.listener.SyncChangeListener;
+import io.objectbox.sync.listener.SyncCompletedListener;
+import io.objectbox.sync.listener.SyncConnectionListener;
+import io.objectbox.sync.listener.SyncListener;
+import io.objectbox.sync.listener.SyncLoginListener;
+import io.objectbox.sync.listener.SyncTimeListener;
+
+/**
+ * A builder to create a {@link SyncClient}; the builder itself should be created via {@link Sync#client(BoxStore)}.
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+public final class SyncBuilder {
+
+    final Platform platform;
+    final BoxStore boxStore;
+    final List<String> urls = new ArrayList<>();
+    final List<SyncCredentials> credentials = new ArrayList<>();
+
+    @Nullable SyncLoginListener loginListener;
+    @Nullable SyncCompletedListener completedListener;
+    @Nullable SyncChangeListener changeListener;
+    @Nullable SyncConnectionListener connectionListener;
+    @Nullable SyncTimeListener timeListener;
+    @Nullable SyncListener listener;
+
+    @Nullable
+    String[] trustedCertPaths;
+    int flags;
+    @Nullable MeshConfig meshConfig;
+    boolean uncommittedAcks;
+
+    RequestUpdatesMode requestUpdatesMode = RequestUpdatesMode.AUTO;
+    // To be helpful when debugging, use a TreeMap so variables are eventually passed ordered by name to the native API
+    final Map<String, String> filterVariables = new TreeMap<>();
+
+    public enum RequestUpdatesMode {
+        /**
+         * Once logged in, does not request any sync updates automatically.
+         * <p>
+         * Sync updates will have to be requested manually.
+         *
+         * @see SyncClient#requestUpdates()
+         * @see SyncClient#requestUpdatesOnce()
+         */
+        MANUAL,
+
+        /**
+         * Once logged in, requests sync updates automatically including subsequent pushes for data changes.
+         * This is the default.
+         */
+        AUTO,
+
+        /**
+         * Once logged in, requests updates automatically once without subsequent pushes for data changes.
+         * <p>
+         * After the initial sync update, further updates will have to be requested manually.
+         *
+         * @see SyncClient#requestUpdates()
+         * @see SyncClient#requestUpdatesOnce()
+         */
+        AUTO_NO_PUSHES
+    }
+
+    /**
+     * Creates a builder for a {@link SyncClient}.
+     * <p>
+     * Don't use this directly, use the {@link Sync#client} method instead.
+     */
+    SyncBuilder(BoxStore boxStore) {
+        checkNotNull(boxStore, "boxStore");
+        this.boxStore = boxStore;
+        NativeLibraryUtils.checkHasFeature();
+        this.platform = Platform.findPlatform(); // Requires APIs only present in Android Sync library
+    }
+
+    /**
+     * Adds a Sync server URL the client should connect to.
+     * <p>
+     * This is typically a WebSockets URL starting with {@code ws://} or {@code wss://} (for encrypted connections), for
+     * example if the server is running on localhost {@code ws://127.0.0.1:9999}.
+     * <p>
+     * Can be called multiple times to add multiple URLs for high availability and load balancing (like when using an
+     * ObjectBox Sync Server Cluster). A random URL is selected for each connection attempt.
+     *
+     * @param url The URL of the Sync server on which the Sync protocol is exposed.
+     * @return this builder for chaining
+     * @see #urls(List)
+     */
+    public SyncBuilder url(String url) {
+        checkNotNull(url, "url");
+        this.urls.add(url);
+        return this;
+    }
+
+    /**
+     * Like {@link #url(String)}, but accepts a list of URLs.
+     *
+     * @param urls A list of URLs of Sync servers on which the Sync protocol is exposed.
+     * @return this builder for chaining
+     * @see #url(String)
+     */
+    public SyncBuilder urls(List<String> urls) {
+        checkNotNull(urls, "urls");
+        for (String url : urls) {
+            url(url);
+        }
+        return this;
+    }
+
+    /**
+     * Adds {@link SyncCredentials} to authenticate the client with the server.
+     * <p>
+     * The accepted credentials types depend on your Sync server configuration.
+     *
+     * @param credentials credentials created using a {@link SyncCredentials} factory method, for example
+     * {@code SyncCredentials.jwtIdToken(idToken)}.
+     * @see #credentials(List)
+     */
+    public SyncBuilder credentials(SyncCredentials credentials) {
+        checkNotNull(credentials, "credentials");
+        this.credentials.add(credentials);
+        return this;
+    }
+
+    /**
+     * Like {@link #credentials(SyncCredentials)}, but accepts a list of credentials.
+     *
+     * @param credentials a list of credentials where each element is created using a {@link SyncCredentials} factory
+     * method, for example {@code SyncCredentials.jwtIdToken(idToken)}.
+     * @return this builder for chaining
+     */
+    public SyncBuilder credentials(List<SyncCredentials> credentials) {
+        checkNotNull(credentials, "credentials");
+        for (SyncCredentials credential : credentials) {
+            credentials(credential);
+        }
+        return this;
+    }
+
+    /**
+     * Adds or replaces a <a href="https://sync.objectbox.io/sync-server/sync-filters">Sync filter</a> variable value
+     * for the given name.
+     * <p>
+     * Sync client filter variables can be used in server-side Sync filters to filter out objects that do not match the
+     * filter.
+     *
+     * @see SyncClient#putFilterVariable
+     */
+    public SyncBuilder filterVariable(String name, String value) {
+        checkNotNull(name, "name");
+        checkNotNull(value, "value");
+        filterVariables.put(name, value);
+        return this;
+    }
+
+    /**
+     * Configures a custom set of directory or file paths to search for trusted certificates in.
+     * The first path that exists will be used.
+     * <p>
+     * Using this option is not recommended in most cases, as by default the sync client uses
+     * the certificate authorities trusted by the host platform.
+     */
+    public SyncBuilder trustedCertificates(String[] paths) {
+        // Copy to prevent external modification.
+        this.trustedCertPaths = Arrays.copyOf(paths, paths.length);
+        return this;
+    }
+
+    /**
+     * Sets bit flags to adjust Sync behavior, like additional logging.
+     *
+     * @param flags One or multiple {@link SyncFlags}, combined with bitwise or.
+     */
+    public SyncBuilder flags(int flags) {
+        this.flags = flags;
+        return this;
+    }
+
+    /**
+     * Configure automatic sync updates from the server.
+     * If automatic sync updates are turned off, they will need to be requested using the sync client.
+     *
+     * @see SyncClient#requestUpdates()
+     * @see SyncClient#requestUpdatesOnce()
+     */
+    public SyncBuilder requestUpdatesMode(RequestUpdatesMode requestUpdatesMode) {
+        this.requestUpdatesMode = requestUpdatesMode;
+        return this;
+    }
+
+    /**
+     * Attaches a peer-to-peer mesh sync configuration to the client.
+     * <p>
+     * A mesh sync is then created together with the client; it starts and stops together with the client.
+     * Query the running mesh via {@link SyncClient#getMesh()}.
+     * <p>
+     * See {@link MeshConfig} for how to obtain a configuration.
+     */
+    @Experimental
+    public SyncBuilder mesh(MeshConfig meshConfig) {
+        checkNotNull(meshConfig, "meshConfig");
+        this.meshConfig = meshConfig;
+        return this;
+    }
+
+    /**
+     * Turns on sending of uncommitted acks.
+     */
+    public SyncBuilder uncommittedAcks() {
+        this.uncommittedAcks = true;
+        return this;
+    }
+
+    /**
+     * Sets a listener to only observe Sync login events.
+     * <p>
+     * This listener can also be {@link SyncClient#setSyncLoginListener(SyncLoginListener) set or removed}
+     * on the Sync client directly.
+     */
+    public SyncBuilder loginListener(SyncLoginListener loginListener) {
+        this.loginListener = loginListener;
+        return this;
+    }
+
+    /**
+     * Sets a listener to only observe Sync completed events.
+     * <p>
+     * This listener can also be {@link SyncClient#setSyncCompletedListener(SyncCompletedListener) set or removed}
+     * on the Sync client directly.
+     */
+    public SyncBuilder completedListener(SyncCompletedListener completedListener) {
+        this.completedListener = completedListener;
+        return this;
+    }
+
+    /**
+     * Sets a listener to observe fine granular changes happening during sync.
+     * <p>
+     * This listener can also be {@link SyncClient#setSyncChangeListener(SyncChangeListener) set or removed}
+     * on the Sync client directly.
+     */
+    public SyncBuilder changeListener(SyncChangeListener changeListener) {
+        this.changeListener = changeListener;
+        return this;
+    }
+
+    /**
+     * Sets a listener to only observe Sync time events.
+     * <p>
+     * This listener can also be {@link SyncClient#setSyncTimeListener(SyncTimeListener) set or removed}
+     * on the Sync client directly.
+     */
+    public SyncBuilder timeListener(SyncTimeListener timeListener) {
+        this.timeListener = timeListener;
+        return this;
+    }
+
+    /**
+     * Sets a listener to only observe Sync connection events.
+     * <p>
+     * This listener can also be {@link SyncClient#setSyncConnectionListener(SyncConnectionListener) set or removed}
+     * on the Sync client directly.
+     */
+    public SyncBuilder connectionListener(SyncConnectionListener connectionListener) {
+        this.connectionListener = connectionListener;
+        return this;
+    }
+
+    /**
+     * Sets a listener to observe all Sync events like login or sync completion.
+     * <p>
+     * Note: this will replace any login, completed or connection listener.
+     * <p>
+     * This listener can also be {@link SyncClient#setSyncListener(SyncListener) set or removed}
+     * on the Sync client directly.
+     */
+    public SyncBuilder listener(SyncListener listener) {
+        this.listener = listener;
+        return this;
+    }
+
+    /**
+     * Builds and returns a Sync client ready to {@link SyncClient#start()}.
+     */
+    public SyncClient build() {
+        if (boxStore.getSyncClient() != null) {
+            throw new IllegalStateException("The given store is already associated with a Sync client, close it first.");
+        }
+        return new SyncClientImpl(this);
+    }
+
+    /**
+     * {@link #build() Builds}, {@link SyncClient#start() starts} and returns a Sync client.
+     */
+    public SyncClient buildAndStart() {
+        SyncClient syncClient = build();
+        syncClient.start();
+        return syncClient;
+    }
+
+    /**
+     * Nullness annotations are only a hint in Java, so explicitly check nonnull annotated parameters
+     * (see package-info.java for package settings).
+     */
+    private void checkNotNull(@Nullable Object object, String name) {
+        if (object == null) {
+            throw new IllegalArgumentException(name + " must not be null.");
+        }
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java
new file mode 100644
index 00000000..ad6d8c66
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncChange.java
@@ -0,0 +1,73 @@
+/*
+ * Copyright 2019-2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Beta;
+import io.objectbox.sync.listener.SyncChangeListener;
+
+// Note: this class is expected to be in this package by JNI, check before modifying/removing it.
+
+/**
+ * A collection of changes made to one entity type during a sync transaction.
+ * Delivered via {@link SyncChangeListener}.
+ * IDs of changed objects are available via {@link #getChangedIds()} and those of removed objects via
+ * {@link #getRemovedIds()}.
+ */
+@SuppressWarnings({"unused", "WeakerAccess"})
+@Beta
+public class SyncChange {
+    final int entityTypeId;
+
+    final long[] changedIds;
+    final long[] removedIds;
+
+    // Note: this constructor is called by JNI, check before modifying/removing it.
+    public SyncChange(int entityTypeId, long[] changedIds, long[] removedIds) {
+        this.entityTypeId = entityTypeId;
+        this.changedIds = changedIds;
+        this.removedIds = removedIds;
+    }
+
+    // Old version called by JNI, remove after some grace period.
+    @Deprecated
+    public SyncChange(long entityTypeId, long[] changedIds, long[] removedIds) {
+        this.entityTypeId = (int) entityTypeId;
+        this.changedIds = changedIds;
+        this.removedIds = removedIds;
+    }
+
+    /**
+     * The entity type ID; use methods like {@link io.objectbox.BoxStore#getEntityTypeIdOrThrow} to map with classes.
+     */
+    public int getEntityTypeId() {
+        return entityTypeId;
+    }
+
+    /**
+     * IDs of objects that have been changed; e.g. have been put/updated/inserted.
+     */
+    public long[] getChangedIds() {
+        return changedIds;
+    }
+
+    /**
+     * IDs of objects that have been removed.
+     */
+    public long[] getRemovedIds() {
+        return removedIds;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java
new file mode 100644
index 00000000..41b3acbe
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncClient.java
@@ -0,0 +1,332 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.io.Closeable;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.sync.SyncBuilder.RequestUpdatesMode;
+import io.objectbox.sync.listener.SyncChangeListener;
+import io.objectbox.sync.listener.SyncCompletedListener;
+import io.objectbox.sync.listener.SyncConnectionListener;
+import io.objectbox.sync.listener.SyncListener;
+import io.objectbox.sync.listener.SyncLoginListener;
+import io.objectbox.sync.listener.SyncTimeListener;
+
+/**
+ * ObjectBox sync client. Build a client with {@link Sync#client}.
+ * <p>
+ * Keep the instance around (avoid garbage collection) while you want to have sync ongoing.
+ * For a clean shutdown, call {@link #close()}.
+ * <p>
+ * SyncClient is thread-safe.
+ */
+@SuppressWarnings("unused")
+public interface SyncClient extends Closeable {
+
+    /**
+     * Gets the sync server URL this client is connected to.
+     *
+     * @deprecated Use {@link #getUrls()}
+     */
+    @Deprecated
+    String getServerUrl();
+
+    /**
+     * Gets the sync server URLs this client may connect to.
+     * <p>
+     * See {@link SyncBuilder#url(String)} for notes on multiple URLs.
+     */
+    List<String> getUrls();
+
+    /**
+     * Returns the running peer-to-peer mesh sync attached to this client, or {@code null} if no {@link MeshConfig}
+     * was passed via {@link SyncBuilder#mesh(MeshConfig)}.
+     * <p>
+     * The mesh starts and stops together with this client. The returned object is owned by this client and valid
+     * until the client is closed.
+     */
+    @Experimental
+    @Nullable
+    MeshSync getMesh();
+
+    /**
+     * Flag indicating if the sync client was started.
+     * Started clients try to connect, login, and sync with the sync destination.
+     */
+    boolean isStarted();
+
+    /**
+     * Flag indicating if the sync client was started.
+     * Logged in clients can sync with the sync destination to exchange data.
+     */
+    boolean isLoggedIn();
+
+    /**
+     * Response code of last login attempt. One of {@link SyncLoginCodes}.
+     */
+    long getLastLoginCode();
+
+    /**
+     * Estimates the current server timestamp in nanoseconds based on the last known server time.
+     *
+     * @return unix timestamp in nanoseconds (since epoch);
+     * or 0 if there has not been a server contact yet and thus the server's time is unknown
+     */
+    long getServerTimeNanos();
+
+    /**
+     * Returns the estimated difference in nanoseconds between the server time and the local timestamp.
+     * urns the difference in nanoseconds between the current local time of this client
+     * Equivalent to calculating {@link #getServerTimeNanos()} - "current time" (nanos since epoch),
+     * except for when the server time is unknown, then the result is zero.
+     *
+     * @return time difference in nanoseconds; e.g. positive if server time is ahead of local time;
+     * or 0 if there has not been a server contact yet and thus the server's time is unknown
+     */
+    long getServerTimeDiffNanos();
+
+    /**
+     * Returns the estimated roundtrip time in nanoseconds to the server and back.
+     * This is measured during login.
+     *
+     * @return roundtrip time in nanoseconds;
+     * or 0 if there has not been a server contact yet and thus the roundtrip time could not be estimated
+     */
+    long getRoundtripTimeNanos();
+
+    /**
+     * Sets a listener to observe login events. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncLoginListener(@Nullable SyncLoginListener listener);
+
+    /**
+     * Sets a listener to observe Sync completed events. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncCompletedListener(@Nullable SyncCompletedListener listener);
+
+    /**
+     * Sets a listener to observe Sync connection events. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncConnectionListener(@Nullable SyncConnectionListener listener);
+
+    /**
+     * Sets a listener to observe all Sync events.
+     * Replaces all other previously set listeners, except a {@link SyncChangeListener}.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncListener(@Nullable SyncListener listener);
+
+    /**
+     * Sets a {@link SyncChangeListener}. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncChangeListener(@Nullable SyncChangeListener listener);
+
+    /**
+     * Sets a {@link SyncTimeListener}. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncTimeListener(@Nullable SyncTimeListener timeListener);
+
+    /**
+     * Adds or replaces a <a href="https://sync.objectbox.io/sync-server/sync-filters">Sync filter</a> variable value
+     * for the given name.
+     * <p>
+     * Note: If the client is already logged in, this change is not applied until {@link #applyFilterVariables()} is
+     * called. This allows to put or remove multiple variables before applying all changes. Filter variables set before
+     * login (before calling {@link #start()}) are automatically applied.
+     * <p>
+     * Eventually, existing values for the same name are replaced.
+     * <p>
+     * Sync client filter variables can be used in server-side Sync filters to filter out objects that do not match the
+     * filter.
+     *
+     * @see #removeFilterVariable
+     * @see #removeAllFilterVariables
+     * @see #applyFilterVariables
+     */
+    void putFilterVariable(String name, String value);
+
+    /**
+     * Removes a previously added Sync filter variable value.
+     * <p>
+     * Note: If the client is already logged in, this change is not applied until {@link #applyFilterVariables()} is
+     * called. See {@link #putFilterVariable} for details.
+     *
+     * @see #putFilterVariable
+     * @see #removeAllFilterVariables
+     */
+    void removeFilterVariable(String name);
+
+    /**
+     * Removes all previously added Sync filter variable values.
+     * <p>
+     * Note: If the client is already logged in, this change is not applied until {@link #applyFilterVariables()} is
+     * called. See {@link #putFilterVariable} for details.
+     *
+     * @see #putFilterVariable
+     * @see #removeFilterVariable
+     */
+    void removeAllFilterVariables();
+
+    /**
+     * Applies all pending Sync filter variable updates (from {@link #putFilterVariable} and
+     * {@link #removeFilterVariable} calls).
+     * <p>
+     * If the client is connected, sends the updated variables to the server. If the client is not connected,
+     * the updated variables will be included in the next login message.
+     *
+     * @see #putFilterVariable
+     * @see #removeFilterVariable
+     * @see #removeAllFilterVariables
+     */
+    void applyFilterVariables();
+
+    /**
+     * Sets credentials to authenticate the client with the server.
+     * <p>
+     * Any credentials that were set before are replaced.
+     * <p>
+     * Usually, credentials are passed via {@link SyncBuilder#credentials(SyncCredentials)}, but this can be used to
+     * update them later, such as when a token expires.
+     * <p>
+     * The accepted credentials type depends on your Sync server configuration.
+     *
+     * @param credentials credentials created using a {@link SyncCredentials} factory method, for example
+     * {@code SyncCredentials.jwtIdToken(idToken)}.
+     * @see #setLoginCredentials(List)
+     */
+    void setLoginCredentials(SyncCredentials credentials);
+
+    /**
+     * Like {@link #setLoginCredentials(SyncCredentials)}, but accepts a list of credentials.
+     *
+     * @param credentials a list of credentials where each element is created using a {@link SyncCredentials} factory
+     * method, for example {@code SyncCredentials.jwtIdToken(idToken)}.
+     */
+    void setLoginCredentials(List<SyncCredentials> credentials);
+
+    /**
+     * Like {@link #setLoginCredentials(SyncCredentials)}, but accepts an array of credentials.
+     *
+     * @param multipleCredentials an array of credentials where each element is created using a {@link SyncCredentials}
+     * factory method, for example {@code SyncCredentials.jwtIdToken(idToken)}.
+     */
+    void setLoginCredentials(SyncCredentials[] multipleCredentials);
+
+    /**
+     * Waits until the sync client receives a response to its first (connection and) login attempt
+     * or until the given time has expired.
+     * Use {@link #isLoggedIn()} or {@link #getLastLoginCode()} afterwards to determine if login was successful.
+     * Starts the sync if it is not already.
+     *
+     * @return true if a response was received in the given time window.
+     */
+    boolean awaitFirstLogin(long millisToWait);
+
+    /**
+     * Starts the client. It will connect to the server, log in (authenticate) and start syncing.
+     */
+    void start();
+
+    /**
+     * Stops the client. Does nothing if the sync client is already stopped.
+     */
+    void stop();
+
+    /**
+     * Closes and cleans up all resources used by this sync client.
+     * It can no longer be used afterwards, build a new sync client instead.
+     * Does nothing if this sync client has already been closed.
+     */
+    void close();
+
+    /**
+     * Asks the sync server to resume sync updates.
+     * This is useful if sync updates were turned off with
+     * {@link SyncBuilder#requestUpdatesMode(RequestUpdatesMode) requestUpdatesMode(MANUAL)}.
+     *
+     * @return 'true' if the request was likely sent (e.g. the sync client is in "logged in" state)
+     * or 'false' if the request was not sent (and will not be sent in the future)
+     * @see #cancelUpdates()
+     */
+    boolean requestUpdates();
+
+    /**
+     * Asks the server to send sync updates until this sync client is up-to-date, then pauses sync updates again.
+     * This is useful if sync updates were turned off with
+     * {@link SyncBuilder#requestUpdatesMode(RequestUpdatesMode) requestUpdatesMode(MANUAL)}.
+     *
+     * @return 'true' if the request was likely sent (e.g. the sync client is in "logged in" state)
+     * or 'false' if the request was not sent (and will not be sent in the future)
+     */
+    boolean requestUpdatesOnce();
+
+    /**
+     * Asks the server to pause sync updates.
+     *
+     * @return 'true' if the request was likely sent (e.g. the sync client is in "logged in" state)
+     * or 'false' if the request was not sent (and will not be sent in the future)
+     * @see #requestUpdates()
+     */
+    boolean cancelUpdates();
+
+    /**
+     * Experimental. This API might change or be removed in the future.
+     * <p>
+     * Temporary only, try not to use it.
+     * <p>
+     * Request a sync of all previous changes from the server.
+     *
+     * @return 'true' if the request was likely sent (e.g. the sync client is in "logged in" state)
+     * or 'false' if the request was not sent (and will not be sent in the future).
+     */
+    @Experimental
+    boolean requestFullSync();
+
+    /**
+     * Lets the sync client know that a working network connection
+     * is available.
+     * <p>
+     * This can help speed up reconnecting to the sync server.
+     */
+    void notifyConnectionAvailable();
+
+    /**
+     * Experimental. This API might change or be removed in the future.
+     * <p>
+     * Start building a message of Objects with optional flags (set to 0) and topic (set to null).
+     * <p>
+     * Use like
+     * <pre>
+     * syncClient.startObjectsMessage(0, "some-topic")
+     *     .addString(1, "Hello!")
+     *     .addBytes(2, "Hello!".getBytes(StandardCharsets.UTF_8), false)
+     *     .send();
+     * </pre>
+     */
+    @Experimental
+    ObjectsMessageBuilder startObjectsMessage(long flags, @Nullable String topic);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java
new file mode 100644
index 00000000..2fb7e357
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncClientImpl.java
@@ -0,0 +1,823 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.InternalAccess;
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.SyncBuilder.RequestUpdatesMode;
+import io.objectbox.sync.listener.SyncChangeListener;
+import io.objectbox.sync.listener.SyncCompletedListener;
+import io.objectbox.sync.listener.SyncConnectionListener;
+import io.objectbox.sync.listener.SyncListener;
+import io.objectbox.sync.listener.SyncLoginListener;
+import io.objectbox.sync.listener.SyncTimeListener;
+
+/**
+ * Internal sync client implementation. Use {@link SyncClient} to access functionality,
+ * this class may change without notice.
+ */
+@Internal
+public final class SyncClientImpl implements SyncClient {
+
+    @Nullable
+    private BoxStore boxStore;
+    private final List<String> urls;
+    private final InternalSyncClientListener internalListener;
+    @Nullable
+    private final ConnectivityMonitor connectivityMonitor;
+
+    private volatile long handle;
+    @Nullable
+    private volatile SyncLoginListener loginListener;
+    @Nullable
+    private volatile SyncCompletedListener completedListener;
+    @Nullable
+    private volatile SyncConnectionListener connectionListener;
+    @Nullable
+    private volatile SyncTimeListener timeListener;
+    private volatile long lastLoginCode;
+    private volatile boolean started;
+    @Nullable
+    private volatile MeshSync mesh;
+
+    SyncClientImpl(SyncBuilder builder) {
+        this.boxStore = builder.boxStore;
+        this.urls = builder.urls;
+        this.connectivityMonitor = builder.platform.getConnectivityMonitor();
+
+        // Build the options
+        long optHandle = nativeSyncOptCreate(builder.boxStore.getNativeStore());
+        if (optHandle == 0) {
+            throw new RuntimeException("Failed to create Sync client options: handle is zero.");
+        }
+        try {
+            // Add all server URLs
+            for (String url : urls) {
+                nativeSyncOptAddUrl(optHandle, url);
+            }
+
+            // Add trusted certificate paths if provided
+            if (builder.trustedCertPaths != null) {
+                for (String certPath : builder.trustedCertPaths) {
+                    nativeSyncOptAddCertPath(optHandle, certPath);
+                }
+            }
+
+            // Add Sync flags if set
+            if (builder.flags != 0) {
+                nativeSyncOptFlags(optHandle, builder.flags);
+            }
+
+            // Attach a mesh sync configuration if set
+            if (builder.meshConfig != null) {
+                applyMeshConfig(optHandle, builder.meshConfig);
+            }
+        } catch (Exception e) {
+            // Free the options if any option method call failed (like due to invalid arguments)
+            nativeSyncOptFree(optHandle);
+            throw e;
+        }
+
+        // Create the sync client (this frees the options in any case)
+        long handle = nativeSyncOptCreateClient(optHandle);
+        if (handle == 0) {
+            throw new RuntimeException("Failed to create Sync client: handle is zero.");
+        }
+        this.handle = handle;
+
+        for (Map.Entry<String, String> entry : builder.filterVariables.entrySet()) {
+            putFilterVariable(entry.getKey(), entry.getValue());
+        }
+
+        // Only change setting if not default (automatic sync updates and push subscription enabled).
+        if (builder.requestUpdatesMode != RequestUpdatesMode.AUTO) {
+            boolean autoRequestUpdates = builder.requestUpdatesMode != RequestUpdatesMode.MANUAL;
+            nativeSetRequestUpdatesMode(handle, autoRequestUpdates, false);
+        }
+        // Only change setting if not default (uncommitted acks are off).
+        if (builder.uncommittedAcks) {
+            nativeSetUncommittedAcks(handle, true);
+        }
+
+        if (builder.listener != null) {
+            setSyncListener(builder.listener);
+        } else {
+            this.loginListener = builder.loginListener;
+            this.completedListener = builder.completedListener;
+            if (builder.changeListener != null) {
+                setSyncChangeListener(builder.changeListener);
+            }
+            this.connectionListener = builder.connectionListener;
+            this.timeListener = builder.timeListener;
+        }
+
+        this.internalListener = new InternalSyncClientListener();
+        nativeSetListener(handle, internalListener);
+
+        setLoginCredentials(builder.credentials);
+
+        // If created successfully, let store keep a reference so the caller does not have to.
+        InternalAccess.setSyncClient(builder.boxStore, this);
+    }
+
+    /**
+     * Builds native mesh options from the given config and attaches them to the sync options.
+     * <p>
+     * Only options with a value are passed to the native API, so the native defaults stay authoritative.
+     * The native library validates the configuration when the sync client is created.
+     */
+    private static void applyMeshConfig(long syncOptHandle, MeshConfig config) {
+        long meshOptHandle = nativeMeshOptCreate(config.meshId);
+        if (meshOptHandle == 0) {
+            throw new RuntimeException("Failed to create mesh options: handle is zero.");
+        }
+        try {
+            if (config.maxConnectionCount != null) {
+                nativeMeshOptMaxConnectionCount(meshOptHandle, config.maxConnectionCount);
+            }
+            if (config.backoffMillis != null) {
+                nativeMeshOptBackoffMillis(meshOptHandle, config.backoffMillis);
+            }
+            if (config.evictionBackoffMillis != null) {
+                nativeMeshOptEvictionBackoffMillis(meshOptHandle, config.evictionBackoffMillis);
+            }
+            if (config.requestTimeoutMillis != null) {
+                nativeMeshOptRequestTimeoutMillis(meshOptHandle, config.requestTimeoutMillis);
+            }
+            if (config.advertisingDelayMillis != null) {
+                nativeMeshOptAdvertisingDelayMillis(meshOptHandle, config.advertisingDelayMillis);
+            }
+            if (config.advertisingRetryMillis != null) {
+                nativeMeshOptAdvertisingRetryMillis(meshOptHandle, config.advertisingRetryMillis);
+            }
+            if (config.advertisingRetryMaxMillis != null) {
+                nativeMeshOptAdvertisingRetryMaxMillis(meshOptHandle, config.advertisingRetryMaxMillis);
+            }
+            if (config.connectDelayMillis != null) {
+                nativeMeshOptConnectDelayMillis(meshOptHandle, config.connectDelayMillis);
+            }
+            if (config.initialDiscoveryDurationSeconds != null) {
+                nativeMeshOptInitialDiscoveryDurationSeconds(meshOptHandle, config.initialDiscoveryDurationSeconds);
+            }
+            if (config.discoveryDurationSeconds != null) {
+                nativeMeshOptDiscoveryDurationSeconds(meshOptHandle, config.discoveryDurationSeconds);
+            }
+            if (config.discoveryPauseSeconds != null) {
+                nativeMeshOptDiscoveryPauseSeconds(meshOptHandle, config.discoveryPauseSeconds);
+            }
+            if (config.discoveryPauseJitterSeconds != null) {
+                nativeMeshOptDiscoveryPauseJitterSeconds(meshOptHandle, config.discoveryPauseJitterSeconds);
+            }
+            if (config.txLogBatchSizeKb != null) {
+                nativeMeshOptTxLogBatchSizeKb(meshOptHandle, config.txLogBatchSizeKb);
+            }
+            if (config.txLogBatchMaxCount != null) {
+                nativeMeshOptTxLogBatchMaxCount(meshOptHandle, config.txLogBatchMaxCount);
+            }
+            for (long networkInternalHandle : config.networkInternalHandles) {
+                nativeMeshOptNetworkInternal(meshOptHandle, networkInternalHandle);
+            }
+        } catch (Exception e) {
+            // Free the mesh options if any option method call failed (like due to invalid arguments)
+            nativeMeshOptFree(meshOptHandle);
+            throw e;
+        }
+        // Attaches and consumes the mesh options (they are freed in any case, also on error)
+        nativeSyncOptMesh(syncOptHandle, meshOptHandle);
+    }
+
+    private long getHandle() {
+        long handle = this.handle;
+        if (handle == 0) {
+            throw new IllegalStateException("SyncClient already closed");
+        }
+        return handle;
+    }
+
+    @Override
+    @Nullable
+    public synchronized MeshSync getMesh() {
+        MeshSync existingMesh = this.mesh;
+        if (existingMesh != null) {
+            return existingMesh;
+        }
+
+        long meshHandle = nativeGetMesh(getHandle());
+        if (meshHandle == 0) return null;
+        MeshSync mesh = new MeshSync(meshHandle);
+        this.mesh = mesh;
+        return mesh;
+    }
+
+    @Override
+    public String getServerUrl() {
+        // nativeSyncOptCreateClient guarantees there is at least one URL
+        return getUrls().get(0);
+    }
+
+    @Override
+    public List<String> getUrls() {
+        return urls;
+    }
+
+    @Override
+    public long getLastLoginCode() {
+        return lastLoginCode;
+    }
+
+    @Override
+    public boolean isLoggedIn() {
+        return lastLoginCode == SyncLoginCodes.OK;
+    }
+
+    @Override
+    public long getServerTimeNanos() {
+        return nativeServerTime(getHandle());
+    }
+
+    @Override
+    public long getServerTimeDiffNanos() {
+        return nativeServerTimeDiff(getHandle());
+    }
+
+    @Override
+    public long getRoundtripTimeNanos() {
+        return nativeRoundtripTime(getHandle());
+    }
+
+    /**
+     * Gets the current state of this sync client. Throws if {@link #close()} was called.
+     */
+    public SyncState getSyncState() {
+        return SyncState.fromId(nativeGetState(getHandle()));
+    }
+
+    @Override
+    public void setSyncLoginListener(@Nullable SyncLoginListener listener) {
+        this.loginListener = listener;
+    }
+
+    @Override
+    public void setSyncCompletedListener(@Nullable SyncCompletedListener listener) {
+        this.completedListener = listener;
+    }
+
+    @Override
+    public void setSyncChangeListener(@Nullable SyncChangeListener changesListener) {
+        nativeSetSyncChangesListener(getHandle(), changesListener);
+    }
+
+    @Override
+    public void setSyncTimeListener(@Nullable SyncTimeListener timeListener) {
+        this.timeListener = timeListener;
+    }
+
+    @Override
+    public void setSyncConnectionListener(@Nullable SyncConnectionListener listener) {
+        this.connectionListener = listener;
+    }
+
+    @Override
+    public void setSyncListener(@Nullable SyncListener listener) {
+        this.loginListener = listener;
+        this.completedListener = listener;
+        this.timeListener = listener;
+        this.connectionListener = listener;
+        setSyncChangeListener(listener);
+    }
+
+    public void putFilterVariable(String name, String value) {
+        nativePutFilterVariable(getHandle(), name, value);
+    }
+
+    public void removeFilterVariable(String name) {
+        nativeRemoveFilterVariable(getHandle(), name);
+    }
+
+    public void removeAllFilterVariables() {
+        nativeRemoveAllFilterVariables(getHandle());
+    }
+
+    public void applyFilterVariables() {
+        nativeApplyFilterVariables(getHandle());
+    }
+
+    @Override
+    public void setLoginCredentials(List<SyncCredentials> credentials) {
+        if (credentials.size() == 1) {
+            setLoginCredentials(credentials.get(0));
+        } else if (credentials.size() > 1) {
+            setLoginCredentials(credentials.toArray(new SyncCredentials[0]));
+        } else {
+            throw new IllegalArgumentException("Credentials must be provided");
+        }
+    }
+
+    @Override
+    public void setLoginCredentials(SyncCredentials credentials) {
+        if (credentials == null) {
+            throw new IllegalArgumentException("credentials must not be null");
+        }
+        if (credentials instanceof SyncCredentialsToken) {
+            SyncCredentialsToken credToken = (SyncCredentialsToken) credentials;
+            nativeSetLoginInfo(getHandle(), credToken.getTypeId(), credToken.getTokenBytes());
+            credToken.clear(); // Clear immediately, not needed anymore.
+        } else if (credentials instanceof SyncCredentialsUserPassword) {
+            SyncCredentialsUserPassword credUserPassword = (SyncCredentialsUserPassword) credentials;
+            nativeSetLoginInfoUserPassword(getHandle(), credUserPassword.getTypeId(), credUserPassword.getUsername(),
+                    credUserPassword.getPassword());
+        } else {
+            throw new IllegalArgumentException("credentials is not a supported type");
+        }
+    }
+
+    @Override
+    public void setLoginCredentials(SyncCredentials[] multipleCredentials) {
+        if (multipleCredentials == null) {
+            throw new IllegalArgumentException("credentials must not be null");
+        }
+        for (int i = 0; i < multipleCredentials.length; i++) {
+            SyncCredentials credentials = multipleCredentials[i];
+            boolean isLast = i == (multipleCredentials.length - 1);
+            if (credentials instanceof SyncCredentialsToken) {
+                SyncCredentialsToken credToken = (SyncCredentialsToken) credentials;
+                nativeAddLoginCredentials(getHandle(), credToken.getTypeId(), credToken.getTokenBytes(), isLast);
+                credToken.clear(); // Clear immediately, not needed anymore.
+            } else if (credentials instanceof SyncCredentialsUserPassword) {
+                SyncCredentialsUserPassword credUserPassword = (SyncCredentialsUserPassword) credentials;
+                nativeAddLoginCredentialsUserPassword(getHandle(), credUserPassword.getTypeId(), credUserPassword.getUsername(),
+                        credUserPassword.getPassword(), isLast);
+            } else {
+                throw new IllegalArgumentException("credentials is not a supported type");
+            }
+        }
+    }
+
+
+    @Override
+    public boolean awaitFirstLogin(long millisToWait) {
+        if (!started) {
+            start();
+        }
+        return internalListener.awaitFirstLogin(millisToWait);
+    }
+
+    @Override
+    public synchronized void start() {
+        nativeStart(getHandle());
+        started = true;
+        if (connectivityMonitor != null) {
+            connectivityMonitor.setObserver(this);
+        }
+    }
+
+    @Override
+    public boolean isStarted() {
+        return started;
+    }
+
+    @Override
+    public synchronized void stop() {
+        if (connectivityMonitor != null) {
+            connectivityMonitor.removeObserver();
+        }
+        nativeStop(getHandle());
+        started = false;
+    }
+
+    @Override
+    public void close() {
+        long handleToDelete;
+        synchronized (this) {
+            if (connectivityMonitor != null) {
+                connectivityMonitor.removeObserver();
+            }
+
+            // Remove instance reference from store, release store reference.
+            BoxStore boxStore = this.boxStore;
+            if (boxStore != null) {
+                SyncClient syncClient = boxStore.getSyncClient();
+                if (syncClient == this) {
+                    InternalAccess.setSyncClient(boxStore, null);
+                }
+                this.boxStore = null;
+            }
+
+            // The native mesh is owned by the client and freed with it; invalidate any MeshSync wrapper so later
+            // access throws instead of using a dangling pointer.
+            MeshSync mesh = this.mesh;
+            if (mesh != null) {
+                mesh.invalidate();
+                this.mesh = null;
+            }
+
+            handleToDelete = this.handle;
+            handle = 0;
+        }
+
+        if (handleToDelete != 0) {
+            nativeDelete(handleToDelete);
+        }
+    }
+
+    /**
+     * Users of this class should explicitly call {@link #close()} instead to avoid expensive finalization.
+     */
+    @SuppressWarnings("deprecation") // finalize()
+    @Override
+    protected void finalize() throws Throwable {
+        close();
+        super.finalize();
+    }
+
+    /**
+     * Temporary only, try not to use it.
+     */
+    @Override
+    @Experimental
+    public boolean requestFullSync() {
+        return nativeRequestFullSync(getHandle(), false);
+    }
+
+    /**
+     * Temporary only, try not to use it.
+     */
+    @Experimental
+    public boolean requestFullSyncAndUpdates() {
+        return nativeRequestFullSync(getHandle(), true);
+    }
+
+    @Override
+    public boolean requestUpdates() {
+        return nativeRequestUpdates(getHandle(), true);
+    }
+
+    @Override
+    public boolean requestUpdatesOnce() {
+        return nativeRequestUpdates(getHandle(), false);
+    }
+
+    @Override
+    public boolean cancelUpdates() {
+        return nativeCancelUpdates(getHandle());
+    }
+
+    @Override
+    public void notifyConnectionAvailable() {
+        nativeTriggerReconnect(getHandle());
+    }
+
+    @Override
+    public ObjectsMessageBuilder startObjectsMessage(long flags, @Nullable String topic) {
+        return new ObjectsMessageBuilderImpl(this, flags, topic);
+    }
+
+    /**
+     * Creates a sync client options object for the given store.
+     * <p>
+     * The options must be configured (at least one URL) and then used with {@link #nativeSyncOptCreateClient}.
+     *
+     * @return handle to the options object, or 0 on error
+     */
+    private static native long nativeSyncOptCreate(long storeHandle);
+
+    /**
+     * Adds a server URL to the sync options; at least one URL must be added before creating the sync client.
+     * <p>
+     * Passing multiple URLs allows high availability and load balancing (i.e. using an ObjectBox Sync Server Cluster).
+     * <p>
+     * A random URL is selected for each connection attempt.
+     */
+    private static native void nativeSyncOptAddUrl(long optHandle, String url);
+
+    /**
+     * Adds a certificate path to the sync options.
+     * <p>
+     * This allows to pass certificate paths referring to the local file system.
+     * <p>
+     * Example use cases are using self-signed certificates in a local development environment and custom certificate
+     * authorities.
+     */
+    private static native void nativeSyncOptAddCertPath(long optHandle, String certPath);
+
+    /**
+     * Sets sync flags to adjust sync behavior; see SyncFlags for available flags.
+     * <p>
+     * Combine multiple flags using bitwise OR.
+     */
+    private static native void nativeSyncOptFlags(long optHandle, int flags);
+
+    /**
+     * Creates a sync client with the given options.
+     * <p>
+     * This does not initiate any connection attempts yet: call {@link #nativeStart} to do so. Before nativeStart(), you
+     * must configure credentials via {@link #nativeSetLoginInfo} or {@link #nativeAddLoginCredentials}.
+     * <p>
+     * By default, a sync client automatically receives updates from the server once login succeeded. To configure this
+     * differently, call {@link #nativeSetRequestUpdatesMode} with the wanted mode.
+     * <p>
+     * Note: the given options are always freed by this function, including when an error occurs.
+     *
+     * @return handle to the sync client, or 0 on error
+     */
+    private static native long nativeSyncOptCreateClient(long optHandle);
+
+    /**
+     * Frees the sync options object.
+     * <p>
+     * Note: Only free *unused* options; {@link #nativeSyncOptCreateClient} frees the options internally.
+     */
+    private static native void nativeSyncOptFree(long optHandle);
+
+    /**
+     * Creates a mesh options object used to configure a peer-to-peer mesh sync.
+     * <p>
+     * Pass it to {@link #nativeSyncOptMesh} to attach it to the sync options; that call frees the mesh options.
+     *
+     * @param meshId the mesh network identifier (required); nodes with different IDs ignore each other.
+     * @return handle to the mesh options object, or 0 on error
+     */
+    private static native long nativeMeshOptCreate(String meshId);
+
+    /**
+     * Frees the mesh options object.
+     * <p>
+     * Note: Only free *unused* options; {@link #nativeSyncOptMesh} frees the mesh options internally.
+     */
+    private static native void nativeMeshOptFree(long meshOptHandle);
+
+    private static native void nativeMeshOptMaxConnectionCount(long meshOptHandle, int count);
+
+    private static native void nativeMeshOptBackoffMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptEvictionBackoffMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptRequestTimeoutMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptAdvertisingDelayMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptAdvertisingRetryMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptAdvertisingRetryMaxMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptConnectDelayMillis(long meshOptHandle, int millis);
+
+    private static native void nativeMeshOptInitialDiscoveryDurationSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptDiscoveryDurationSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptDiscoveryPauseSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptDiscoveryPauseJitterSeconds(long meshOptHandle, int seconds);
+
+    private static native void nativeMeshOptTxLogBatchSizeKb(long meshOptHandle, int sizeKb);
+
+    private static native void nativeMeshOptTxLogBatchMaxCount(long meshOptHandle, int count);
+
+    /**
+     * Registers an internal mesh network (transport) implementation with the mesh options.
+     * <p>
+     * Networks are platform-specific (e.g. Android Nearby) and are created by ObjectBox platform libraries.
+     *
+     * @param networkInternalHandle an internal handle to a native mesh network.
+     */
+    private static native void nativeMeshOptNetworkInternal(long meshOptHandle, long networkInternalHandle);
+
+    /**
+     * Attaches a mesh sync configuration to the sync options.
+     * <p>
+     * When the sync client is created ({@link #nativeSyncOptCreateClient}), a mesh sync is created from this
+     * configuration and attached to the client; it starts and stops together with the client. Use
+     * {@link #nativeGetMesh} to query the running mesh.
+     * <p>
+     * Note: the given mesh options are always freed by this function, including when an error occurs.
+     */
+    private static native void nativeSyncOptMesh(long optHandle, long meshOptHandle);
+
+    /**
+     * Returns a handle to the mesh sync attached to the sync client (configured via {@link #nativeSyncOptMesh}),
+     * or 0 if no mesh sync is attached.
+     * <p>
+     * The mesh sync is owned by the sync client; the handle is valid as long as the sync client is not closed.
+     */
+    private native long nativeGetMesh(long handle);
+
+    private native void nativeDelete(long handle);
+
+    private native void nativeStart(long handle);
+
+    private native void nativeStop(long handle);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativePutFilterVariable(JNIEnv* env, jobject, jlong handle, jstring name, jstring value)
+    private native void nativePutFilterVariable(long handle, String name, String value);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativeRemoveFilterVariable(JNIEnv* env, jobject, jlong handle, jstring name)
+    private native void nativeRemoveFilterVariable(long handle, String name);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativeRemoveAllFilterVariables(JNIEnv* env, jobject, jlong handle)
+    private native void nativeRemoveAllFilterVariables(long handle);
+
+    // extern "C" JNIEXPORT void JNICALL Java_io_objectbox_sync_SyncClientImpl_nativeApplyFilterVariables(JNIEnv* env, jobject, jlong handle)
+    private native void nativeApplyFilterVariables(long handle);
+
+    private native void nativeSetLoginInfo(long handle, long credentialsType, @Nullable byte[] credentials);
+
+    private native void nativeSetLoginInfoUserPassword(long handle, long credentialsType, String username, String password);
+
+    private native void nativeAddLoginCredentials(long handle, long credentialsType, @Nullable byte[] credentials, boolean complete);
+
+    private native void nativeAddLoginCredentialsUserPassword(long handle, long credentialsType, String username, String password, boolean complete);
+
+    private native void nativeSetListener(long handle, @Nullable InternalSyncClientListener listener);
+
+    private native void nativeSetSyncChangesListener(long handle, @Nullable SyncChangeListener advancedListener);
+
+    /** @param subscribeForPushes Pass true to automatically receive updates for future changes. */
+    private native void nativeSetRequestUpdatesMode(long handle, boolean autoRequestUpdates, boolean subscribeForPushes);
+
+    /**
+     * @param uncommittedAcks Default is false.
+     */
+    private native void nativeSetUncommittedAcks(long handle, boolean uncommittedAcks);
+
+    /**
+     * Returns the current {@link SyncState} value.
+     */
+    private native int nativeGetState(long handle);
+
+    /** @param subscribeForPushes Pass true to automatically receive updates for future changes. */
+    private native boolean nativeRequestUpdates(long handle, boolean subscribeForPushes);
+
+    /** @param subscribeForPushes Pass true to automatically receive updates for future changes. */
+    private native boolean nativeRequestFullSync(long handle, boolean subscribeForPushes);
+
+    /** (Optional) Pause sync updates. */
+    private native boolean nativeCancelUpdates(long handle);
+
+    /**
+     * Hints to the native client that an active network connection is available.
+     * Returns true if the native client was disconnected (and will try to re-connect).
+     */
+    private native boolean nativeTriggerReconnect(long handle);
+
+    /**
+     * The current server timestamp approximation based on the last server time
+     * we've received and local steady clock.
+     *
+     * @return unix timestamp in nanoseconds
+     */
+    private native long nativeServerTime(long handle);
+
+    /**
+     * Returns the difference between the current local timestamp and the current
+     * server timestamp approximation as given by nativeServerTime().
+     * Equivalent to calculating: nanosSinceEpoch - nativeServerTime().
+     *
+     * @return unix timestamp difference in nanoseconds
+     */
+    private native long nativeServerTimeDiff(long handle);
+
+    private native long nativeRoundtripTime(long handle);
+
+    /**
+     * Returns a handle to the message builder.
+     *
+     * @see #nativeObjectsMessageAddBytes
+     * @see #nativeObjectsMessageAddString
+     */
+    private native long nativeObjectsMessageStart(long flags, @Nullable String topic);
+
+    /**
+     * @see #nativeObjectsMessageSend
+     */
+    private native void nativeObjectsMessageAddString(long builderHandle, long optionalId, String string);
+
+    /**
+     * @see #nativeObjectsMessageSend
+     */
+    private native void nativeObjectsMessageAddBytes(long builderHandle, long optionalId, byte[] bytes, boolean isFlatBuffer);
+
+    /**
+     * Do not use {@code builderHandle} afterwards.
+     */
+    private native boolean nativeObjectsMessageSend(long syncClientHandle, long builderHandle);
+
+    /**
+     * Methods on this class must match those expected by JNI implementation.
+     */
+    @SuppressWarnings("unused") // Methods called from native code.
+    private class InternalSyncClientListener {
+        private final CountDownLatch firstLoginLatch = new CountDownLatch(1);
+
+        public void onLogin() {
+            lastLoginCode = SyncLoginCodes.OK;
+            firstLoginLatch.countDown();
+
+            SyncLoginListener listenerToFire = loginListener;
+            if (listenerToFire != null) {
+                listenerToFire.onLoggedIn();
+            }
+        }
+
+        public void onLoginFailure(long errorCode) {
+            lastLoginCode = errorCode;
+            firstLoginLatch.countDown();
+
+            SyncLoginListener listenerToFire = loginListener;
+            if (listenerToFire != null) {
+                listenerToFire.onLoginFailed(errorCode);
+            }
+        }
+
+        public void onSyncComplete() {
+            SyncCompletedListener listenerToFire = completedListener;
+            if (listenerToFire != null) {
+                listenerToFire.onUpdatesCompleted();
+            }
+        }
+
+        public void onServerTimeUpdate(long serverTimeNanos) {
+            SyncTimeListener listenerToFire = timeListener;
+            if (listenerToFire != null) {
+                listenerToFire.onServerTimeUpdate(serverTimeNanos);
+            }
+        }
+
+        public void onDisconnect() {
+            SyncConnectionListener listenerToFire = connectionListener;
+            if (listenerToFire != null) {
+                listenerToFire.onDisconnected();
+            }
+        }
+
+        boolean awaitFirstLogin(long millisToWait) {
+            try {
+                return firstLoginLatch.await(millisToWait, TimeUnit.MILLISECONDS);
+            } catch (InterruptedException e) {
+                return false;
+            }
+        }
+    }
+
+    public static class ObjectsMessageBuilderImpl implements ObjectsMessageBuilder {
+        private boolean sent;
+        private final long builderHandle;
+        private final SyncClientImpl syncClient;
+
+        private ObjectsMessageBuilderImpl(SyncClientImpl syncClient, long flags, @Nullable String topic) {
+            this.syncClient = syncClient;
+            this.builderHandle = syncClient.nativeObjectsMessageStart(flags, topic);
+        }
+
+        @Override
+        public ObjectsMessageBuilderImpl addString(long optionalId, String value) {
+            checkNotSent();
+            syncClient.nativeObjectsMessageAddString(builderHandle, optionalId, value);
+            return this;
+        }
+
+        @Override
+        public ObjectsMessageBuilderImpl addBytes(long optionalId, byte[] value, boolean isFlatBuffers) {
+            checkNotSent();
+            syncClient.nativeObjectsMessageAddBytes(builderHandle, optionalId, value, isFlatBuffers);
+            return this;
+        }
+
+        @Override
+        public boolean send() {
+            if (!syncClient.isStarted()) {
+                return false;
+            }
+            checkNotSent();
+            sent = true;
+            return syncClient.nativeObjectsMessageSend(syncClient.getHandle(), builderHandle);
+        }
+
+        private void checkNotSent() {
+            if (sent) throw new IllegalStateException("Already sent this message, start a new one instead.");
+        }
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java
new file mode 100644
index 00000000..77e1120e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentials.java
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+/**
+ * Use the static helper methods to build Sync credentials,
+ * for example {@link #sharedSecret(String) SyncCredentials.sharedSecret("secret")}.
+ */
+@SuppressWarnings("unused")
+public abstract class SyncCredentials {
+
+    private final CredentialsType type;
+
+    /**
+     * Authenticate with a shared secret. This could be a passphrase, big number or randomly chosen bytes.
+     * The string is expected to use UTF-8 characters.
+     */
+    public static SyncCredentials sharedSecret(String secret) {
+        return new SyncCredentialsToken(CredentialsType.SHARED_SECRET_SIPPED, secret);
+    }
+
+    /**
+     * Authenticate with a shared secret. This could be a passphrase, big number or randomly chosen bytes.
+     */
+    public static SyncCredentials sharedSecret(byte[] secret) {
+        return new SyncCredentialsToken(CredentialsType.SHARED_SECRET_SIPPED, secret);
+    }
+
+    /**
+     * Authenticate with a Google account ID token obtained via
+     * <a href="https://developers.google.com/identity/sign-in/android/backend-auth" target="_top">Google Sign-In</a>.
+     */
+    public static SyncCredentials google(String idToken) {
+        return new SyncCredentialsToken(CredentialsType.GOOGLE, idToken);
+    }
+
+    /**
+     * ObjectBox Admin user (username and password).
+     */
+    public static SyncCredentials obxAdminUser(String user, String password) {
+        return new SyncCredentialsUserPassword(CredentialsType.OBX_ADMIN_USER, user, password);
+    }
+
+    /**
+     * Generic credentials type suitable for ObjectBox Admin (and possibly others in the future).
+     */
+    public static SyncCredentials userAndPassword(String user, String password) {
+        return new SyncCredentialsUserPassword(CredentialsType.USER_PASSWORD, user, password);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is an ID token.
+     * <p>
+     * An ID token typically provides identity information about the authenticated user.
+     * <p>
+     * Use this and the other JWT methods that accept a token to configure JWT auth for a Sync client or server peer.
+     * To configure Sync server auth options, use the server variants, like {@link #jwtIdTokenServer()}, instead.
+     * <p>
+     * See the <a href="https://sync.objectbox.io/sync-server-configuration/jwt-authentication">JWT authentication documentation</a>
+     * for details.
+     */
+    public static SyncCredentials jwtIdToken(String jwtIdToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_ID_TOKEN, jwtIdToken);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is an access token.
+     * <p>
+     * An access token is used to access resources.
+     * <p>
+     * See {@link #jwtIdToken(String)} for some common remarks.
+     */
+    public static SyncCredentials jwtAccessToken(String jwtAccessToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_ACCESS_TOKEN, jwtAccessToken);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is a refresh token.
+     * <p>
+     * A refresh token is used to obtain a new access token.
+     * <p>
+     * See {@link #jwtIdToken(String)} for some common remarks.
+     */
+    public static SyncCredentials jwtRefreshToken(String jwtRefreshToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_REFRESH_TOKEN, jwtRefreshToken);
+    }
+
+    /**
+     * Authenticate with a JSON Web Token (JWT) that is neither an ID, access, nor refresh token.
+     * <p>
+     * See {@link #jwtIdToken(String)} for some common remarks.
+     */
+    public static SyncCredentials jwtCustomToken(String jwtCustomToken) {
+        return new SyncCredentialsToken(CredentialsType.JWT_CUSTOM_TOKEN, jwtCustomToken);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is an ID token.
+     * <p>
+     * An ID token typically provides identity information about the authenticated user.
+     * <p>
+     * Use this and the other JWT server credentials types to configure a Sync server.
+     * For Sync clients, use the ones that accept a token, like {@link #jwtIdToken(String)}, instead.
+     * <p>
+     * See the <a href="https://sync.objectbox.io/sync-server-configuration/jwt-authentication">JWT authentication documentation</a>
+     * for details.
+     */
+    public static SyncCredentials jwtIdTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_ID_TOKEN);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is an access token.
+     * <p>
+     * An access token is used to access resources.
+     * <p>
+     * See {@link #jwtIdTokenServer()} for some common remarks.
+     */
+    public static SyncCredentials jwtAccessTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_ACCESS_TOKEN);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is a refresh token.
+     * <p>
+     * A refresh token is used to obtain a new access token.
+     * <p>
+     * See {@link #jwtIdTokenServer()} for some common remarks.
+     */
+    public static SyncCredentials jwtRefreshTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_REFRESH_TOKEN);
+    }
+
+    /**
+     * Enable authentication using a JSON Web Token (JWT) that is neither an ID, access, nor refresh token.
+     * <p>
+     * See {@link #jwtIdTokenServer()} for some common remarks.
+     */
+    public static SyncCredentials jwtCustomTokenServer() {
+        return new SyncCredentialsToken(CredentialsType.JWT_CUSTOM_TOKEN);
+    }
+
+    /**
+     * No authentication, unsecured. Use only for development and testing purposes.
+     */
+    public static SyncCredentials none() {
+        return new SyncCredentialsToken(CredentialsType.NONE);
+    }
+
+    public enum CredentialsType {
+
+        NONE(io.objectbox.sync.CredentialsType.None),
+        GOOGLE(io.objectbox.sync.CredentialsType.GoogleAuth),
+        SHARED_SECRET_SIPPED(io.objectbox.sync.CredentialsType.SharedSecretSipped),
+        OBX_ADMIN_USER(io.objectbox.sync.CredentialsType.ObxAdminUser),
+        USER_PASSWORD(io.objectbox.sync.CredentialsType.UserPassword),
+        JWT_ID_TOKEN(io.objectbox.sync.CredentialsType.JwtId),
+        JWT_ACCESS_TOKEN(io.objectbox.sync.CredentialsType.JwtAccess),
+        JWT_REFRESH_TOKEN(io.objectbox.sync.CredentialsType.JwtRefresh),
+        JWT_CUSTOM_TOKEN(io.objectbox.sync.CredentialsType.JwtCustom);
+
+        public final long id;
+
+        CredentialsType(long id) {
+            this.id = id;
+        }
+    }
+
+    SyncCredentials(CredentialsType type) {
+        this.type = type;
+    }
+
+    public CredentialsType getType() {
+        return type;
+    }
+
+    public long getTypeId() {
+        return type.id;
+    }
+
+    /**
+     * Creates a copy of these credentials.
+     * <p>
+     * This can be useful to use the same credentials when creating multiple clients or a server in combination with a
+     * client as some credentials may get cleared when building a client or server.
+     */
+    abstract SyncCredentials createClone();
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java
new file mode 100644
index 00000000..55ceff13
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsToken.java
@@ -0,0 +1,95 @@
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Internal credentials implementation. Use {@link SyncCredentials} to build credentials.
+ */
+@Internal
+public final class SyncCredentialsToken extends SyncCredentials {
+
+    @Nullable private byte[] token;
+    private volatile boolean cleared;
+
+    SyncCredentialsToken(CredentialsType type) {
+        super(type);
+        this.token = null;
+    }
+
+    SyncCredentialsToken(CredentialsType type, byte[] token) {
+        this(type);
+        // Annotations do not guarantee non-null values
+        //noinspection ConstantValue
+        if (token == null || token.length == 0) {
+            throw new IllegalArgumentException("Token must not be empty");
+        }
+        this.token = token;
+    }
+
+    SyncCredentialsToken(CredentialsType type, String token) {
+        this(type, token.getBytes(StandardCharsets.UTF_8));
+    }
+
+    public boolean hasToken() {
+        return token != null;
+    }
+
+    @Nullable
+    public byte[] getTokenBytes() {
+        if (cleared) {
+            throw new IllegalStateException("Credentials already have been cleared");
+        }
+        return token;
+    }
+
+    /**
+     * Clear after usage.
+     * <p>
+     * Note that when the token is passed as a String, that String is removed from memory at the earliest with the next
+     * garbage collector run.
+     * <p>
+     * Also note that while the token is removed from the Java heap, it is present on the native heap of the Sync
+     * component using it.
+     */
+    public void clear() {
+        cleared = true;
+        byte[] tokenToClear = this.token;
+        if (tokenToClear != null) {
+            Arrays.fill(tokenToClear, (byte) 0);
+        }
+        this.token = null;
+    }
+
+    @Override
+    SyncCredentialsToken createClone() {
+        if (cleared) {
+            throw new IllegalStateException("Cannot clone: credentials already have been cleared");
+        }
+        if (token == null) {
+            return new SyncCredentialsToken(getType());
+        } else {
+            return new SyncCredentialsToken(getType(), Arrays.copyOf(token, token.length));
+        }
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsUserPassword.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsUserPassword.java
new file mode 100644
index 00000000..62d9e53f
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncCredentialsUserPassword.java
@@ -0,0 +1,49 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Internal;
+
+/**
+ * Internal credentials implementation for user and password authentication.
+ * Use {@link SyncCredentials} to build credentials.
+ */
+@Internal
+public final class SyncCredentialsUserPassword extends SyncCredentials {
+
+    private final String username;
+    private final String password;
+
+    SyncCredentialsUserPassword(CredentialsType type, String username, String password) {
+        super(type);
+        this.username = username;
+        this.password = password;
+    }
+
+    public String getUsername() {
+        return username;
+    }
+
+    public String getPassword() {
+        return password;
+    }
+
+    @Override
+    SyncCredentials createClone() {
+        return new SyncCredentialsUserPassword(getType(), this.username, this.password);
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java
new file mode 100644
index 00000000..08051585
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncFlags.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. https://objectbox.io
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync;
+
+/**
+ * Flags to adjust sync behavior like additional logging.
+ */
+@SuppressWarnings("unused")
+public final class SyncFlags {
+  private SyncFlags() { }
+  /**
+   * Enable (rather extensive) logging on how IDs are mapped (local &lt;-&gt; global)
+   */
+  public static final int DebugLogIdMapping = 1;
+  /**
+   * If the client gets in a state that does not allow any further synchronization, this flag instructs Sync to
+   * keep local data nevertheless. While this preserves data, you need to resolve the situation manually.
+   * For example, you could backup the data and start with a fresh database.
+   * Note that the default behavior (this flag is not set) is to wipe existing data from all sync-enabled types and
+   * sync from scratch from the server.
+   * Client-only: setting this flag for Sync server has no effect.
+   */
+  public static final int ClientKeepDataOnSyncError = 2;
+  /**
+   * Logs sync filter variables used for each client, e.g. values provided by JWT or the client's login message.
+   * Server-only: setting this flag for Sync client has no effect.
+   */
+  public static final int DebugLogFilterVariables = 4;
+  /**
+   * When set, remove operations will include the full object data in the TX log (REMOVE_OBJECT command).
+   * This allows sync filters to filter out remove operations based on the object content.
+   * Without this flag, remove operations only contain the object ID and cannot be filtered.
+   * Note: this increases the size of TX logs for remove operations.
+   */
+  public static final int RemoveWithObjectData = 8;
+  /**
+   * Enables debug logging of TX log processing.
+   * For now, this only has an effect on SyncClients (Sync Server has extensive debug logs already).
+   */
+  public static final int DebugLogTxLogs = 16;
+  /**
+   * Skips invalid (put object) operations in the TX log instead of failing.
+   */
+  public static final int SkipInvalidTxOps = 32;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncHybrid.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybrid.java
new file mode 100644
index 00000000..cb2b19d2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybrid.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import java.io.Closeable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.sync.server.SyncServer;
+
+/**
+ * Combines the functionality of a Sync client and a Sync server.
+ * <p>
+ * It is typically used in local cluster setups, in which a "hybrid" functions as a client and cluster peer (server).
+ * <p>
+ * Call {@link #getStore()} to retrieve the store. To set sync listeners use the {@link SyncClient} that is available
+ * from {@link #getClient()}.
+ * <p>
+ * This class implements the {@link Closeable} interface, ensuring that resources are cleaned up properly.
+ */
+public final class SyncHybrid implements Closeable {
+    private BoxStore store;
+    private final SyncClient client;
+    private BoxStore storeServer;
+    private final SyncServer server;
+
+    SyncHybrid(BoxStore store, SyncClient client, BoxStore storeServer, SyncServer server) {
+        this.store = store;
+        this.client = client;
+        this.storeServer = storeServer;
+        this.server = server;
+    }
+
+    public BoxStore getStore() {
+        return store;
+    }
+
+    /**
+     * Returns the {@link SyncClient} of this hybrid, typically only to set Sync listeners.
+     * <p>
+     * Note: do not stop or close the client directly. Instead, use the {@link #stop()} and {@link #close()} methods of
+     * this hybrid.
+     */
+    public SyncClient getClient() {
+        return client;
+    }
+
+    /**
+     * Returns the {@link SyncServer} of this hybrid.
+     * <p>
+     * Typically, the server should not be touched. Yet, it is still exposed for advanced use cases.
+     * <p>
+     * Note: do not stop or close the server directly. Instead, use the {@link #stop()} and {@link #close()} methods of
+     * this hybrid.
+     */
+    public SyncServer getServer() {
+        return server;
+    }
+
+    /**
+     * Stops the client and server.
+     */
+    public void stop() {
+        client.stop();
+        server.stop();
+    }
+
+    /**
+     * Closes and cleans up all resources used by this Sync hybrid.
+     * <p>
+     * It can no longer be used afterward, build a new one instead.
+     * <p>
+     * Does nothing if this has already been closed.
+     */
+    @Override
+    public void close() {
+        // Clear reference to boxStore but do not close it (same behavior as SyncClient and SyncServer)
+        store = null;
+        client.close();
+        server.close();
+        if (storeServer != null) {
+            storeServer.close(); // The server store is "internal", so can safely close it
+            storeServer = null;
+        }
+    }
+
+    /**
+     * Users of this class should explicitly call {@link #close()} instead to avoid expensive finalization.
+     */
+    @SuppressWarnings("deprecation") // finalize()
+    @Override
+    protected void finalize() throws Throwable {
+        close();
+        super.finalize();
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncHybridBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybridBuilder.java
new file mode 100644
index 00000000..1cade53b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncHybridBuilder.java
@@ -0,0 +1,85 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.BoxStore;
+import io.objectbox.BoxStoreBuilder;
+import io.objectbox.InternalAccess;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.server.SyncServer;
+import io.objectbox.sync.server.SyncServerBuilder;
+
+/**
+ * Builder for a Sync client and server hybrid setup, a {@link SyncHybrid}.
+ * <p>
+ * To change the server/cluster configuration, call {@link #serverBuilder()}, and for the client configuration
+ * {@link #clientBuilder()}.
+ */
+@SuppressWarnings({"unused", "UnusedReturnValue"})
+public final class SyncHybridBuilder {
+
+    private final BoxStore boxStore;
+    private final BoxStore boxStoreServer;
+    private final SyncBuilder clientBuilder;
+    private final SyncServerBuilder serverBuilder;
+
+    /**
+     * Internal API; use {@link Sync#hybrid(BoxStoreBuilder, String, SyncCredentials)} instead.
+     */
+    @Internal
+    SyncHybridBuilder(BoxStoreBuilder storeBuilder, String url, SyncCredentials authenticatorCredentials) {
+        BoxStoreBuilder storeBuilderServer = InternalAccess.clone(storeBuilder, "-server");
+        boxStore = storeBuilder.build();
+        boxStoreServer = storeBuilderServer.build();
+        SyncCredentials clientCredentials = authenticatorCredentials.createClone();
+        // Do not yet set URL, port may only be chosen once server is started, see buildAndStart()
+        clientBuilder = new SyncBuilder(boxStore).credentials(clientCredentials);
+        serverBuilder = new SyncServerBuilder(boxStoreServer, url, authenticatorCredentials);
+    }
+
+    /**
+     * Returns the builder of the client of the hybrid for additional configuration.
+     */
+    public SyncBuilder clientBuilder() {
+        return clientBuilder;
+    }
+
+    /**
+     * Returns the builder of the server of the hybrid for additional configuration.
+     */
+    public SyncServerBuilder serverBuilder() {
+        return serverBuilder;
+    }
+
+    /**
+     * Builds, starts and returns the hybrid.
+     * <p>
+     * Ensures the correct order of starting the server and client.
+     */
+    @SuppressWarnings("resource") // User is responsible for closing
+    public SyncHybrid buildAndStart() {
+        // Build and start the server first to obtain its URL, the port may have been set to 0 and dynamically assigned
+        SyncServer server = serverBuilder.buildAndStart();
+
+        SyncClient client = clientBuilder
+                .url(server.getUrl())
+                .buildAndStart();
+
+        return new SyncHybrid(boxStore, client, boxStoreServer, server);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java
new file mode 100644
index 00000000..10f70b8e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncLoginCodes.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2019-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.sync.listener.SyncListener;
+
+/**
+ * Codes used by {@link SyncListener#onLoginFailed(long)}.
+ */
+@Experimental
+public class SyncLoginCodes {
+
+    public static final long OK = 20;
+    public static final long REQ_REJECTED = 40;
+    public static final long CREDENTIALS_REJECTED = 43;
+    public static final long UNKNOWN = 50;
+    public static final long AUTH_UNREACHABLE = 53;
+    public static final long BAD_VERSION = 55;
+    public static final long CLIENT_ID_TAKEN = 61;
+    public static final long TX_VIOLATED_UNIQUE = 71;
+
+    private SyncLoginCodes() {
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java b/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java
new file mode 100644
index 00000000..ea94f188
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/SyncState.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2019-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+/**
+ * Returned by {@link io.objectbox.sync.SyncClientImpl#getSyncState()}.
+ */
+public enum SyncState {
+
+    UNKNOWN(0),
+    CREATED(1),
+    STARTED(2),
+    CONNECTED(3),
+    LOGGED_IN(4),
+    DISCONNECTED(5),
+    STOPPED(6),
+    DEAD(7);
+
+    public final int id;
+
+    SyncState(int id) {
+        this.id = id;
+    }
+
+    public static SyncState fromId(int id) {
+        for (SyncState value : values()) {
+            if (value.id == id) return value;
+        }
+        return UNKNOWN;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java b/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java
new file mode 100644
index 00000000..76bb39aa
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/internal/Platform.java
@@ -0,0 +1,68 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.internal;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.sync.ConnectivityMonitor;
+
+/**
+ * Provides access to platform-specific features.
+ */
+public class Platform {
+
+    public static Platform findPlatform() {
+        // Android
+        Object contextInstance = BoxStore.getContext();
+        if (contextInstance != null) {
+            Throwable throwable = null;
+
+            // Note: do not catch Exception as it will swallow exceptions useful for debugging.
+            // Also can't catch ReflectiveOperationException, is K+ (19+) on Android.
+            // noinspection TryWithIdenticalCatches Requires Android K+ (19+).
+            try {
+                Class<?> contextClass = Class.forName("android.content.Context");
+                Class<?> platformClass = Class.forName("io.objectbox.android.internal.AndroidPlatform");
+                Method create = platformClass.getMethod("create", contextClass);
+                return (Platform) create.invoke(null, contextInstance);
+            } catch (NoSuchMethodException e) {
+                throwable = e;
+            } catch (IllegalAccessException e) {
+                throwable = e;
+            } catch (InvocationTargetException e) {
+                throwable = e;
+            } catch (ClassNotFoundException ignored) {
+                // Android API or library not in classpath.
+            }
+
+            if (throwable != null) {
+                throw new RuntimeException("AndroidPlatform could not be created.", throwable);
+            }
+        }
+
+        return new Platform();
+    }
+
+    @Nullable
+    public ConnectivityMonitor getConnectivityMonitor() {
+        return null;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java
new file mode 100644
index 00000000..34392c30
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/AbstractSyncListener.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.sync.SyncChange;
+
+/**
+ * A {@link SyncListener} with empty implementations of all interface methods.
+ * This is helpful if you only want to override some methods.
+ */
+@Experimental
+public abstract class AbstractSyncListener implements SyncListener {
+
+    @Override
+    public void onLoggedIn() {
+    }
+
+    @Override
+    public void onLoginFailed(long syncLoginCode) {
+    }
+
+    @Override
+    public void onUpdatesCompleted() {
+    }
+
+    @Override
+    public void onSyncChanges(SyncChange[] syncChanges) {
+    }
+
+    @Override
+    public void onServerTimeUpdate(long serverTimeNanos) {
+    }
+
+    @Override
+    public void onDisconnected() {
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java
new file mode 100644
index 00000000..993c4180
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncChangeListener.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright 2019-2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.sync.SyncChange;
+
+/**
+ * Notifies of fine granular changes on the object level happening during sync.
+ * Register your listener using {@link io.objectbox.sync.SyncBuilder#changeListener(SyncChangeListener) SyncBuilder.changesListener(SyncChangesListener)}.
+ * Note that enabling fine granular notification can slightly reduce performance.
+ * <p>
+ * See also {@link SyncListener} for the general sync listener.
+ */
+@SuppressWarnings({"unused"})
+@Experimental
+public interface SyncChangeListener {
+
+    // Note: this method is expected by JNI, check before modifying/removing it.
+
+    /**
+     * Called each time when data from sync was applied locally.
+     *
+     * @param syncChanges This contains the entity type (schema) ID, the removed IDs and the put IDs for that entity.
+     */
+    void onSyncChanges(SyncChange[] syncChanges);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java
new file mode 100644
index 00000000..de67dc54
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncCompletedListener.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+/**
+ * Listens to sync completed events.
+ */
+public interface SyncCompletedListener {
+
+    /**
+     * Called each time a sync was "completed", in the sense that the client caught up with the current server state.
+     * The client is "up-to-date".
+     */
+    void onUpdatesCompleted();
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java
new file mode 100644
index 00000000..b3622f47
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncConnectionListener.java
@@ -0,0 +1,32 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+/**
+ * Listens to sync connection events.
+ */
+public interface SyncConnectionListener {
+
+    /**
+     * Called when the client is disconnected from the sync server, e.g. due to a network error.
+     * <p>
+     * Depending on the configuration, the sync client typically tries to reconnect automatically,
+     * triggering a {@link SyncLoginListener} again.
+     */
+    void onDisconnected();
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java
new file mode 100644
index 00000000..5a2c7ab2
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncListener.java
@@ -0,0 +1,33 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.sync.SyncBuilder;
+import io.objectbox.sync.SyncClient;
+
+/**
+ * This listener has callback methods invoked by all fundamental synchronization events.
+ * Set via {@link SyncBuilder#listener(SyncListener)} or {@link SyncClient#setSyncListener(SyncListener)}.
+ * <p>
+ * See {@link AbstractSyncListener} for a no-op convenience implementation.
+ * <p>
+ * Use more specific listeners, like {@link SyncLoginListener}, to only receive a sub-set of events.
+ */
+@Experimental
+public interface SyncListener extends SyncLoginListener, SyncCompletedListener, SyncChangeListener, SyncConnectionListener, SyncTimeListener {
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java
new file mode 100644
index 00000000..fe70a3fb
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncLoginListener.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+import io.objectbox.sync.SyncLoginCodes;
+
+/**
+ * Listens to login events.
+ */
+public interface SyncLoginListener {
+
+    /**
+     * Called on a successful login.
+     * <p>
+     * At this point the connection to the sync destination was established and
+     * entered an operational state, in which data can be sent both ways.
+     */
+    void onLoggedIn();
+
+    /**
+     * Called on a login failure. One of {@link SyncLoginCodes}, but never {@link SyncLoginCodes#OK}.
+     */
+    void onLoginFailed(long syncLoginCode);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java
new file mode 100644
index 00000000..ec6355cb
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/listener/SyncTimeListener.java
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.listener;
+
+public interface SyncTimeListener {
+
+    /**
+     * Called when server time information is received on the client.
+     */
+    void onServerTimeUpdate(long serverTimeNanos);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/package-info.java b/objectbox-java/src/main/java/io/objectbox/sync/package-info.java
new file mode 100644
index 00000000..0b385d9e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/package-info.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * <a href="https://objectbox.io/sync/">ObjectBox Sync</a> allows to automatically synchronize local data with a sync
+ * destination (e.g. a sync server) and vice versa. This is the sync <b>client</b> package.
+ * <p>
+ * These are the typical steps to set up a sync client:
+ * <ol>
+ *     <li>Create a BoxStore as usual (using MyObjectBox).</li>
+ *     <li>Build a {@link io.objectbox.sync.SyncClient} using
+ *     {@link io.objectbox.sync.Sync#client(io.objectbox.BoxStore) Sync.client(boxStore)}, a
+ *     {@link io.objectbox.sync.SyncBuilder#url(java.lang.String)} and at least one set of credentials with
+ *     {@link io.objectbox.sync.SyncBuilder#credentials(io.objectbox.sync.SyncCredentials)}.</li>
+ *     <li>Optional: use the {@link io.objectbox.sync.SyncBuilder} instance from the last step to configure the sync
+ *     client and set initial listeners.</li>
+ *     <li>Call {@link io.objectbox.sync.SyncBuilder#buildAndStart()} to get an instance of
+ *     {@link io.objectbox.sync.SyncClient} (and hold on to it). Synchronization is now active.</li>
+ *     <li>Optional: Interact with {@link io.objectbox.sync.SyncClient}.</li>
+ * </ol>
+ */
+@ParametersAreNonnullByDefault
+package io.objectbox.sync;
+
+import javax.annotation.ParametersAreNonnullByDefault;
\ No newline at end of file
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterFlags.java b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterFlags.java
new file mode 100644
index 00000000..ce03bf99
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterFlags.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+/**
+ * Special bit flags used in cluster mode only.
+ */
+@SuppressWarnings("unused")
+public final class ClusterFlags {
+  private ClusterFlags() { }
+  /**
+   * Indicates that this cluster always stays in the "follower" cluster role.
+   * Thus, it does not participate in leader elections.
+   * This is useful e.g. for weaker cluster nodes that should not become leaders.
+   */
+  public static final int FixedFollower = 1;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerConfig.java b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerConfig.java
new file mode 100644
index 00000000..5c4316d8
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerConfig.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * Configuration to connect to another (remote) cluster peer.
+ * If this server is started in cluster mode, it connects to other cluster peers.
+ */
+@SuppressWarnings("unused")
+public final class ClusterPeerConfig extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static ClusterPeerConfig getRootAsClusterPeerConfig(ByteBuffer _bb) { return getRootAsClusterPeerConfig(_bb, new ClusterPeerConfig()); }
+  public static ClusterPeerConfig getRootAsClusterPeerConfig(ByteBuffer _bb, ClusterPeerConfig obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public ClusterPeerConfig __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  public String url() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer urlAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public ByteBuffer urlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+  public io.objectbox.sync.Credentials credentials() { return credentials(new io.objectbox.sync.Credentials()); }
+  public io.objectbox.sync.Credentials credentials(io.objectbox.sync.Credentials obj) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+
+  public static int createClusterPeerConfig(FlatBufferBuilder builder,
+      int urlOffset,
+      int credentialsOffset) {
+    builder.startTable(2);
+    ClusterPeerConfig.addCredentials(builder, credentialsOffset);
+    ClusterPeerConfig.addUrl(builder, urlOffset);
+    return ClusterPeerConfig.endClusterPeerConfig(builder);
+  }
+
+  public static void startClusterPeerConfig(FlatBufferBuilder builder) { builder.startTable(2); }
+  public static void addUrl(FlatBufferBuilder builder, int urlOffset) { builder.addOffset(0, urlOffset, 0); }
+  public static void addCredentials(FlatBufferBuilder builder, int credentialsOffset) { builder.addOffset(1, credentialsOffset, 0); }
+  public static int endClusterPeerConfig(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public ClusterPeerConfig get(int j) { return get(new ClusterPeerConfig(), j); }
+    public ClusterPeerConfig get(ClusterPeerConfig obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerInfo.java b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerInfo.java
new file mode 100644
index 00000000..bc815455
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/ClusterPeerInfo.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2019-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.server;
+
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.SyncCredentialsToken;
+
+/**
+ * Internal class to keep configuration for a cluster peer.
+ */
+@Internal
+final class ClusterPeerInfo {
+    String url;
+    SyncCredentialsToken credentials;
+
+    ClusterPeerInfo(String url, SyncCredentialsToken credentials) {
+        this.url = url;
+        this.credentials = credentials;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/JwtConfig.java b/objectbox-java/src/main/java/io/objectbox/sync/server/JwtConfig.java
new file mode 100644
index 00000000..02f9b3f0
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/JwtConfig.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+@SuppressWarnings("unused")
+public final class JwtConfig extends Table {
+    public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+    public static JwtConfig getRootAsJwtConfig(ByteBuffer _bb) { return getRootAsJwtConfig(_bb, new JwtConfig()); }
+    public static JwtConfig getRootAsJwtConfig(ByteBuffer _bb, JwtConfig obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+    public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+    public JwtConfig __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+    /**
+     * URL to fetch the current public key used to verify JWT signatures.
+     */
+    public String publicKeyUrl() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer publicKeyUrlAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+    public ByteBuffer publicKeyUrlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+    /**
+     * Fixed public key used to sign JWT tokens; e.g. for development purposes.
+     * Supply either publicKey or publicKeyUrl, but not both.
+     */
+    public String publicKey() { int o = __offset(6); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer publicKeyAsByteBuffer() { return __vector_as_bytebuffer(6, 1); }
+    public ByteBuffer publicKeyInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 6, 1); }
+    /**
+     * Cache expiration time in seconds for the public key(s) fetched from publicKeyUrl.
+     * If absent or zero, the default is used.
+     */
+    public long publicKeyCacheExpirationSeconds() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+    /**
+     * JWT claim "aud" (audience) used to verify JWT tokens.
+     */
+    public String claimAud() { int o = __offset(10); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer claimAudAsByteBuffer() { return __vector_as_bytebuffer(10, 1); }
+    public ByteBuffer claimAudInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 10, 1); }
+    /**
+     * JWT claim "iss" (issuer) used to verify JWT tokens.
+     */
+    public String claimIss() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; }
+    public ByteBuffer claimIssAsByteBuffer() { return __vector_as_bytebuffer(12, 1); }
+    public ByteBuffer claimIssInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); }
+
+    public static int createJwtConfig(FlatBufferBuilder builder,
+                                      int publicKeyUrlOffset,
+                                      int publicKeyOffset,
+                                      long publicKeyCacheExpirationSeconds,
+                                      int claimAudOffset,
+                                      int claimIssOffset) {
+        builder.startTable(5);
+        JwtConfig.addClaimIss(builder, claimIssOffset);
+        JwtConfig.addClaimAud(builder, claimAudOffset);
+        JwtConfig.addPublicKeyCacheExpirationSeconds(builder, publicKeyCacheExpirationSeconds);
+        JwtConfig.addPublicKey(builder, publicKeyOffset);
+        JwtConfig.addPublicKeyUrl(builder, publicKeyUrlOffset);
+        return JwtConfig.endJwtConfig(builder);
+    }
+
+    public static void startJwtConfig(FlatBufferBuilder builder) { builder.startTable(5); }
+    public static void addPublicKeyUrl(FlatBufferBuilder builder, int publicKeyUrlOffset) { builder.addOffset(0, publicKeyUrlOffset, 0); }
+    public static void addPublicKey(FlatBufferBuilder builder, int publicKeyOffset) { builder.addOffset(1, publicKeyOffset, 0); }
+    public static void addPublicKeyCacheExpirationSeconds(FlatBufferBuilder builder, long publicKeyCacheExpirationSeconds) { builder.addInt(2, (int) publicKeyCacheExpirationSeconds, (int) 0L); }
+    public static void addClaimAud(FlatBufferBuilder builder, int claimAudOffset) { builder.addOffset(3, claimAudOffset, 0); }
+    public static void addClaimIss(FlatBufferBuilder builder, int claimIssOffset) { builder.addOffset(4, claimIssOffset, 0); }
+    public static int endJwtConfig(FlatBufferBuilder builder) {
+        int o = builder.endTable();
+        return o;
+    }
+
+    public static final class Vector extends BaseVector {
+        public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+        public JwtConfig get(int j) { return get(new JwtConfig(), j); }
+        public JwtConfig get(JwtConfig obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+    }
+}
\ No newline at end of file
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java
new file mode 100644
index 00000000..b70d4b37
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServer.java
@@ -0,0 +1,78 @@
+/*
+ * Copyright 2019-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.server;
+
+import java.io.Closeable;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.sync.Sync;
+import io.objectbox.sync.listener.SyncChangeListener;
+
+/**
+ * ObjectBox sync server. Build a server with {@link Sync#server}.
+ */
+@SuppressWarnings("unused")
+public interface SyncServer extends Closeable {
+
+    /**
+     * Returns the URL this server is listening on, including the bound port (see {@link #getPort()}).
+     */
+    String getUrl();
+
+    /**
+     * Returns the port this server listens on, or 0 if the server was not yet started.
+     * <p>
+     * This is especially useful if the port was assigned arbitrarily (a "0" port was used in the URL when building the
+     * server).
+     */
+    int getPort();
+
+    /**
+     * Returns if the server is up and running.
+     */
+    boolean isRunning();
+
+    /**
+     * Gets some statistics from the sync server.
+     */
+    String getStatsString();
+
+    /**
+     * Sets a {@link SyncChangeListener}. Replaces a previously set listener.
+     * Set to {@code null} to remove the listener.
+     */
+    void setSyncChangeListener(@Nullable SyncChangeListener listener);
+
+    /**
+     * Starts the server (e.g. bind to port) and gets everything operational.
+     */
+    void start();
+
+    /**
+     * Stops the server.
+     */
+    void stop();
+
+    /**
+     * Closes and cleans up all resources used by this sync server.
+     * It can no longer be used afterwards, build a new sync server instead.
+     * Does nothing if this sync server has already been closed.
+     */
+    void close();
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java
new file mode 100644
index 00000000..7e2045b6
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerBuilder.java
@@ -0,0 +1,490 @@
+/*
+ * Copyright 2019-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.server;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.internal.NativeLibraryUtils;
+import io.objectbox.sync.Credentials;
+import io.objectbox.sync.Sync;
+import io.objectbox.sync.SyncCredentials;
+import io.objectbox.sync.SyncCredentialsToken;
+import io.objectbox.sync.SyncFlags;
+import io.objectbox.sync.listener.SyncChangeListener;
+
+/**
+ * Creates a {@link SyncServer} and allows to set additional configuration.
+ */
+@SuppressWarnings({"unused", "UnusedReturnValue"})
+public final class SyncServerBuilder {
+
+    final BoxStore boxStore;
+    final URI url;
+    private final List<SyncCredentialsToken> credentials = new ArrayList<>();
+
+    private @Nullable String certificatePath;
+    SyncChangeListener changeListener;
+    private @Nullable String clusterId;
+    private final List<ClusterPeerInfo> clusterPeers = new ArrayList<>();
+    private int clusterFlags;
+    private long historySizeMaxKb;
+    private long historySizeTargetKb;
+    private int syncFlags;
+    private int syncServerFlags;
+    private int workerThreads;
+
+    private @Nullable String jwtPublicKey;
+    private @Nullable String jwtPublicKeyUrl;
+    private @Nullable String jwtClaimIss;
+    private @Nullable String jwtClaimAud;
+
+    /**
+     * Use {@link Sync#server(BoxStore, String, SyncCredentials)} instead.
+     */
+    @Internal
+    public SyncServerBuilder(BoxStore boxStore, String url, SyncCredentials authenticatorCredentials) {
+        checkNotNull(boxStore, "BoxStore is required.");
+        checkNotNull(url, "Sync server URL is required.");
+        checkNotNull(authenticatorCredentials, "Authenticator credentials are required.");
+        NativeLibraryUtils.checkHasSyncServerFeature();
+        this.boxStore = boxStore;
+        try {
+            this.url = new URI(url);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException("Sync server URL is invalid: " + url, e);
+        }
+        authenticatorCredentials(authenticatorCredentials);
+    }
+
+    /**
+     * Use {@link Sync#server(BoxStore, String, SyncCredentials)} instead.
+     */
+    @Internal
+    public SyncServerBuilder(BoxStore boxStore, String url, SyncCredentials[] multipleAuthenticatorCredentials) {
+        checkNotNull(boxStore, "BoxStore is required.");
+        checkNotNull(url, "Sync server URL is required.");
+        checkNotNull(multipleAuthenticatorCredentials, "Authenticator credentials are required.");
+        NativeLibraryUtils.checkHasSyncServerFeature();
+        this.boxStore = boxStore;
+        try {
+            this.url = new URI(url);
+        } catch (URISyntaxException e) {
+            throw new IllegalArgumentException("Sync server URL is invalid: " + url, e);
+        }
+        for (SyncCredentials credentials : multipleAuthenticatorCredentials) {
+            authenticatorCredentials(credentials);
+        }
+    }
+
+    /**
+     * Sets the path to a directory that contains a cert.pem and key.pem file to use to establish encrypted
+     * connections.
+     * <p>
+     * Use the "wss://" protocol for the server URL to turn on encrypted connections.
+     */
+    public SyncServerBuilder certificatePath(String certificatePath) {
+        checkNotNull(certificatePath, "Certificate path must not be null");
+        this.certificatePath = certificatePath;
+        return this;
+    }
+
+    /**
+     * Adds additional authenticator credentials to authenticate clients or peers with.
+     * <p>
+     * For the embedded server, currently only {@link SyncCredentials#sharedSecret}, any JWT method like
+     * {@link SyncCredentials#jwtIdTokenServer()} as well as {@link SyncCredentials#none} are supported.
+     */
+    public SyncServerBuilder authenticatorCredentials(SyncCredentials authenticatorCredentials) {
+        checkNotNull(authenticatorCredentials, "Authenticator credentials must not be null.");
+        if (!(authenticatorCredentials instanceof SyncCredentialsToken)) {
+            throw new IllegalArgumentException("Sync credentials of type " + authenticatorCredentials.getType()
+                    + " are not supported");
+        }
+        SyncCredentialsToken tokenCredential = (SyncCredentialsToken) authenticatorCredentials;
+        SyncCredentials.CredentialsType type = tokenCredential.getType();
+        switch (type) {
+            case JWT_ID_TOKEN:
+            case JWT_ACCESS_TOKEN:
+            case JWT_REFRESH_TOKEN:
+            case JWT_CUSTOM_TOKEN:
+                if (tokenCredential.hasToken()) {
+                    throw new IllegalArgumentException("Must not supply a token for a credential of type "
+                            + authenticatorCredentials.getType());
+                }
+        }
+        credentials.add(tokenCredential);
+        return this;
+    }
+
+    /**
+     * Sets a listener to observe fine granular changes happening during sync.
+     * <p>
+     * This listener can also be {@link SyncServer#setSyncChangeListener(SyncChangeListener) set or removed} on the Sync
+     * server directly.
+     */
+    public SyncServerBuilder changeListener(SyncChangeListener changeListener) {
+        this.changeListener = changeListener;
+        return this;
+    }
+
+    /**
+     * Enables cluster mode (requires the Cluster feature) and associates this cluster peer with the given ID.
+     * <p>
+     * Cluster peers need to share the same ID to be in the same cluster.
+     *
+     * @see #clusterPeer(String, SyncCredentials)
+     * @see #clusterFlags(int)
+     */
+    public SyncServerBuilder clusterId(String id) {
+        checkNotNull(id, "Cluster ID must not be null");
+        this.clusterId = id;
+        return this;
+    }
+
+    /**
+     * Adds a (remote) cluster peer, to which this server should connect to as a client using the given credentials.
+     * <p>
+     * To use this, must set a {@link #clusterId(String)}.
+     */
+    public SyncServerBuilder clusterPeer(String url, SyncCredentials credentials) {
+        if (!(credentials instanceof SyncCredentialsToken)) {
+            throw new IllegalArgumentException("Sync credentials of type " + credentials.getType()
+                    + " are not supported");
+        }
+        clusterPeers.add(new ClusterPeerInfo(url, (SyncCredentialsToken) credentials));
+        return this;
+    }
+
+    /**
+     * Sets bit flags to configure the cluster behavior of the Sync server (aka cluster peer).
+     * <p>
+     * To use this, must set a {@link #clusterId(String)}.
+     *
+     * @param flags One or more of {@link ClusterFlags}.
+     */
+    public SyncServerBuilder clusterFlags(int flags) {
+        this.clusterFlags = flags;
+        return this;
+    }
+
+    /**
+     * Sets the maximum transaction history size.
+     * <p>
+     * Once the maximum size is reached, old transaction logs are deleted to stay below this limit. This is sometimes
+     * also called "history pruning" in the context of Sync.
+     * <p>
+     * If not set or set to 0, defaults to no limit.
+     *
+     * @see #historySizeTargetKb(long)
+     */
+    public SyncServerBuilder historySizeMaxKb(long historySizeMaxKb) {
+        this.historySizeMaxKb = historySizeMaxKb;
+        return this;
+    }
+
+    /**
+     * Sets the target transaction history size.
+     * <p>
+     * Once the maximum size ({@link #historySizeMaxKb(long)}) is reached, old transaction logs are deleted until this
+     * size target is reached (lower than the maximum size). Using this target size typically lowers the frequency of
+     * history pruning and thus may improve efficiency.
+     * <p>
+     * If not set or set to 0, defaults to {@link #historySizeMaxKb(long)}.
+     */
+    public SyncServerBuilder historySizeTargetKb(long historySizeTargetKb) {
+        this.historySizeTargetKb = historySizeTargetKb;
+        return this;
+    }
+
+    /**
+     * Sets bit flags to adjust Sync behavior, like additional logging.
+     *
+     * @param syncFlags One or more of {@link SyncFlags}.
+     */
+    public SyncServerBuilder syncFlags(int syncFlags) {
+        this.syncFlags = syncFlags;
+        return this;
+    }
+
+    /**
+     * Sets bit flags to configure the Sync server.
+     *
+     * @param syncServerFlags One or more of {@link SyncServerFlags}.
+     */
+    public SyncServerBuilder syncServerFlags(int syncServerFlags) {
+        this.syncServerFlags = syncServerFlags;
+        return this;
+    }
+
+    /**
+     * Sets the number of workers for the main task pool.
+     * <p>
+     * If not set or set to 0, this uses a hardware-dependant default, e.g. 3 * CPU "cores".
+     */
+    public SyncServerBuilder workerThreads(int workerThreads) {
+        this.workerThreads = workerThreads;
+        return this;
+    }
+
+    /**
+     * Sets the public key used to verify JWT tokens.
+     * <p>
+     * The public key should be in the PEM format.
+     * <p>
+     * However, typically the key is supplied using a JWKS file served from a {@link #jwtPublicKeyUrl(String)}.
+     * <p>
+     * See {@link #jwtPublicKeyUrl(String)} for a common configuration to enable JWT auth.
+     */
+    public SyncServerBuilder jwtPublicKey(String publicKey) {
+        this.jwtPublicKey = publicKey;
+        return this;
+    }
+
+    /**
+     * Sets the JWKS (Json Web Key Sets) URL to fetch the current public key used to verify JWT tokens.
+     * <p>
+     * A working JWT configuration can look like this:
+     * <pre>{@code
+     * SyncCredentials auth = SyncCredentials.jwtIdTokenServer();
+     * SyncServer server = Sync.server(store, url, auth)
+     *         .jwtPublicKeyUrl("https://example.com/public-key")
+     *         .jwtClaimAud("<audience>")
+     *         .jwtClaimIss("<issuer>")
+     *         .build();
+     * }</pre>
+     *
+     * See the <a href="https://sync.objectbox.io/sync-server-configuration/jwt-authentication">JWT authentication documentation</a>
+     * for details.
+     */
+    public SyncServerBuilder jwtPublicKeyUrl(String publicKeyUrl) {
+        this.jwtPublicKeyUrl = publicKeyUrl;
+        return this;
+    }
+
+    /**
+     * Sets the JWT claim "iss" (issuer) used to verify JWT tokens.
+     *
+     * @see #jwtPublicKeyUrl(String)
+     */
+    public SyncServerBuilder jwtClaimIss(String claimIss) {
+        this.jwtClaimIss = claimIss;
+        return this;
+    }
+
+    /**
+     * Sets the JWT claim "aud" (audience) used to verify JWT tokens.
+     *
+     * @see #jwtPublicKeyUrl(String)
+     */
+    public SyncServerBuilder jwtClaimAud(String claimAud) {
+        this.jwtClaimAud = claimAud;
+        return this;
+    }
+
+    private boolean hasJwtConfig() {
+        return jwtPublicKey != null || jwtPublicKeyUrl != null;
+    }
+
+    /**
+     * Builds and returns a Sync server ready to {@link SyncServer#start()}.
+     * <p>
+     * Note: this clears all previously set authenticator credentials.
+     */
+    public SyncServer build() {
+        // Note: even when only using JWT auth, must supply one of the credentials of JWT type
+        if (credentials.isEmpty()) {
+            throw new IllegalStateException("At least one authenticator is required.");
+        }
+        if (hasJwtConfig()) {
+            if (jwtClaimAud == null) {
+                throw new IllegalArgumentException("To use JWT authentication, claimAud must be set");
+            }
+            if (jwtClaimIss == null) {
+                throw new IllegalArgumentException("To use JWT authentication, claimIss must be set");
+            }
+        }
+        if (!clusterPeers.isEmpty() || clusterFlags != 0) {
+            checkNotNull(clusterId, "Cluster ID must be set to use cluster features.");
+        }
+        return new SyncServerImpl(this);
+    }
+
+    /**
+     * Builds, {@link SyncServer#start() starts} and returns a Sync server.
+     */
+    public SyncServer buildAndStart() {
+        SyncServer syncServer = build();
+        syncServer.start();
+        return syncServer;
+    }
+
+    private void checkNotNull(Object object, String message) {
+        if (object == null) {
+            throw new IllegalArgumentException(message);
+        }
+    }
+
+    /**
+     * From this configuration, builds a {@link SyncServerOptions} FlatBuffer and returns it as bytes.
+     * <p>
+     * Clears configured credentials, they can not be used again after this returns.
+     */
+    byte[] buildSyncServerOptions() {
+        FlatBufferBuilder fbb = new FlatBufferBuilder();
+        // Always put values, even if they match the default values (defined in the generated classes)
+        fbb.forceDefaults(true);
+
+        // Serialize non-integer values first to get their offset
+        int urlOffset = fbb.createString(url.toString());
+        int certificatePathOffset = 0;
+        if (certificatePath != null) {
+            certificatePathOffset = fbb.createString(certificatePath);
+        }
+        int clusterIdOffset = 0;
+        if (clusterId != null) {
+            clusterIdOffset = fbb.createString(clusterId);
+        }
+        int authenticationMethodsOffset = buildAuthenticationMethods(fbb);
+        int clusterPeersVectorOffset = buildClusterPeers(fbb);
+        int jwtConfigOffset = 0;
+        if (hasJwtConfig()) {
+            jwtConfigOffset = buildJwtConfig(fbb, jwtPublicKey, jwtPublicKeyUrl, jwtClaimIss, jwtClaimAud);
+        }
+        // Clear credentials immediately to make abuse less likely,
+        // but only after setting all options to allow (re-)using the same credentials object
+        // for authentication and cluster peers login credentials.
+        for (SyncCredentialsToken credential : credentials) {
+            credential.clear();
+        }
+        for (ClusterPeerInfo peer : clusterPeers) {
+            peer.credentials.clear();
+        }
+
+        // After collecting all offsets, create options
+        SyncServerOptions.startSyncServerOptions(fbb);
+        SyncServerOptions.addUrl(fbb, urlOffset);
+        SyncServerOptions.addAuthenticationMethods(fbb, authenticationMethodsOffset);
+        if (syncFlags != 0) {
+            SyncServerOptions.addSyncFlags(fbb, syncFlags);
+        }
+        if (syncServerFlags != 0) {
+            SyncServerOptions.addSyncFlags(fbb, syncServerFlags);
+        }
+        if (certificatePathOffset != 0) {
+            SyncServerOptions.addCertificatePath(fbb, certificatePathOffset);
+        }
+        if (workerThreads != 0) {
+            SyncServerOptions.addWorkerThreads(fbb, workerThreads);
+        }
+        if (historySizeMaxKb != 0) {
+            SyncServerOptions.addHistorySizeMaxKb(fbb, historySizeMaxKb);
+        }
+        if (historySizeTargetKb != 0) {
+            SyncServerOptions.addHistorySizeTargetKb(fbb, historySizeTargetKb);
+        }
+        if (clusterIdOffset != 0) {
+            SyncServerOptions.addClusterId(fbb, clusterIdOffset);
+        }
+        if (clusterPeersVectorOffset != 0) {
+            SyncServerOptions.addClusterPeers(fbb, clusterPeersVectorOffset);
+        }
+        if (clusterFlags != 0) {
+            SyncServerOptions.addClusterFlags(fbb, clusterFlags);
+        }
+        if (jwtConfigOffset != 0) {
+            SyncServerOptions.addJwtConfig(fbb, jwtConfigOffset);
+        }
+        int offset = SyncServerOptions.endSyncServerOptions(fbb);
+        fbb.finish(offset);
+
+        return fbb.sizedByteArray();
+    }
+
+    private int buildAuthenticationMethods(FlatBufferBuilder fbb) {
+        int[] credentialsOffsets = new int[credentials.size()];
+        for (int i = 0; i < credentials.size(); i++) {
+            credentialsOffsets[i] = buildCredentials(fbb, credentials.get(i));
+        }
+        return SyncServerOptions.createAuthenticationMethodsVector(fbb, credentialsOffsets);
+    }
+
+    private int buildCredentials(FlatBufferBuilder fbb, SyncCredentialsToken tokenCredentials) {
+        int tokenBytesOffset = 0;
+        byte[] tokenBytes = tokenCredentials.getTokenBytes();
+        if (tokenBytes != null) {
+            tokenBytesOffset = Credentials.createBytesVector(fbb, tokenBytes);
+        }
+
+        Credentials.startCredentials(fbb);
+        Credentials.addType(fbb, tokenCredentials.getTypeId());
+        if (tokenBytesOffset != 0) {
+            Credentials.addBytes(fbb, tokenBytesOffset);
+        }
+        return Credentials.endCredentials(fbb);
+    }
+
+    private int buildJwtConfig(FlatBufferBuilder fbb, @Nullable String publicKey, @Nullable String publicKeyUrl, String claimIss, String claimAud) {
+        if (publicKey == null && publicKeyUrl == null) {
+            throw new IllegalArgumentException("Either publicKey or publicKeyUrl must be set");
+        }
+        int publicKeyOffset = 0;
+        int publicKeyUrlOffset = 0;
+        if (publicKey != null) {
+            publicKeyOffset = fbb.createString(publicKey);
+        } else {
+            publicKeyUrlOffset = fbb.createString(publicKeyUrl);
+        }
+        int claimIssOffset = fbb.createString(claimIss);
+        int claimAudOffset = fbb.createString(claimAud);
+        JwtConfig.startJwtConfig(fbb);
+        if (publicKeyOffset != 0) {
+            JwtConfig.addPublicKey(fbb, publicKeyOffset);
+        } else {
+            JwtConfig.addPublicKeyUrl(fbb, publicKeyUrlOffset);
+        }
+        JwtConfig.addClaimIss(fbb, claimIssOffset);
+        JwtConfig.addClaimAud(fbb, claimAudOffset);
+        return JwtConfig.endJwtConfig(fbb);
+    }
+
+    private int buildClusterPeers(FlatBufferBuilder fbb) {
+        if (clusterPeers.isEmpty()) {
+            return 0;
+        }
+
+        int[] peersOffsets = new int[clusterPeers.size()];
+        for (int i = 0; i < clusterPeers.size(); i++) {
+            ClusterPeerInfo peer = clusterPeers.get(i);
+
+            int urlOffset = fbb.createString(peer.url);
+            int credentialsOffset = buildCredentials(fbb, peer.credentials);
+
+            peersOffsets[i] = ClusterPeerConfig.createClusterPeerConfig(fbb, urlOffset, credentialsOffset);
+        }
+
+        return SyncServerOptions.createClusterPeersVector(fbb, peersOffsets);
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerFlags.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerFlags.java
new file mode 100644
index 00000000..ab037f2e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerFlags.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+/**
+ * Bit flags to configure the Sync Server.
+ */
+@SuppressWarnings("unused")
+public final class SyncServerFlags {
+  private SyncServerFlags() { }
+  /**
+   * By default, if the Sync Server allows logins without credentials, it logs a warning message.
+   * If this flag is set, the message is logged only as "info".
+   */
+  public static final int AuthenticationNoneLogInfo = 1;
+  /**
+   * By default, the Admin server is enabled; this flag disables it.
+   */
+  public static final int AdminDisabled = 2;
+  /**
+   * By default, the Sync Server logs messages when it starts and stops; this flag disables it.
+   */
+  public static final int LogStartStopDisabled = 4;
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java
new file mode 100644
index 00000000..ae126816
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerImpl.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2019-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync.server;
+
+import java.net.URI;
+import java.net.URISyntaxException;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.sync.listener.SyncChangeListener;
+
+/**
+ * Internal sync server implementation. Use {@link SyncServer} to access functionality,
+ * this class may change without notice.
+ */
+@Internal
+public final class SyncServerImpl implements SyncServer {
+
+    private final URI url;
+    private volatile long handle;
+
+    /**
+     * Protects listener instance from garbage collection.
+     */
+    @SuppressWarnings("unused")
+    @Nullable
+    private volatile SyncChangeListener syncChangeListener;
+
+    SyncServerImpl(SyncServerBuilder builder) {
+        this.url = builder.url;
+
+        long storeHandle = builder.boxStore.getNativeStore();
+        long handle = nativeCreateFromFlatOptions(storeHandle, builder.buildSyncServerOptions());
+        if (handle == 0) {
+            throw new RuntimeException("Failed to create sync server: handle is zero.");
+        }
+        this.handle = handle;
+
+        if (builder.changeListener != null) {
+            setSyncChangeListener(builder.changeListener);
+        }
+    }
+
+    private long getHandle() {
+        long handle = this.handle;
+        if (handle == 0) {
+            throw new IllegalStateException("SyncServer already closed");
+        }
+        return handle;
+    }
+
+    @Override
+    public String getUrl() {
+        try {
+            return new URI(url.getScheme(), null, url.getHost(), getPort(), null, null, null).toString();
+        } catch (URISyntaxException e) {
+            throw new RuntimeException("Server URL can not be constructed", e);
+        }
+    }
+
+    @Override
+    public int getPort() {
+        return nativeGetPort(getHandle());
+    }
+
+    @Override
+    public boolean isRunning() {
+        long handle = this.handle;  // Do not call getHandle() as it throws if handle is 0
+        return handle != 0 && nativeIsRunning(handle);
+    }
+
+    @Override
+    public String getStatsString() {
+        return nativeGetStatsString(getHandle());
+    }
+
+    @Override
+    public void setSyncChangeListener(@Nullable SyncChangeListener changesListener) {
+        this.syncChangeListener = changesListener;
+        nativeSetSyncChangesListener(getHandle(), changesListener);
+    }
+
+    @Override
+    public void start() {
+        nativeStart(getHandle());
+    }
+
+    @Override
+    public void stop() {
+        nativeStop(getHandle());
+    }
+
+    @Override
+    public void close() {
+        long handleToDelete = handle;
+        handle = 0;
+        if (handleToDelete != 0) {
+            nativeDelete(handleToDelete);
+        }
+    }
+
+    /**
+     * Users of this class should explicitly call {@link #close()} instead to avoid expensive finalization.
+     */
+    @SuppressWarnings("deprecation") // finalize()
+    @Override
+    protected void finalize() throws Throwable {
+        close();
+        super.finalize();
+    }
+
+    /**
+     * Creates a native Sync server instance with FlatBuffer {@link SyncServerOptions} {@code flatOptionsByteArray}.
+     *
+     * @return The handle of the native server instance.
+     */
+    private static native long nativeCreateFromFlatOptions(long storeHandle, byte[] flatOptionsByteArray);
+
+    private native void nativeDelete(long handle);
+
+    private native void nativeStart(long handle);
+
+    private native void nativeStop(long handle);
+
+    private native boolean nativeIsRunning(long handle);
+
+    private native int nativeGetPort(long handle);
+
+    private native String nativeGetStatsString(long handle);
+
+    private native void nativeSetSyncChangesListener(long handle, @Nullable SyncChangeListener changesListener);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerOptions.java b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerOptions.java
new file mode 100644
index 00000000..7ca1e66a
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/sync/server/SyncServerOptions.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// automatically generated by the FlatBuffers compiler, do not modify
+
+package io.objectbox.sync.server;
+
+import io.objectbox.flatbuffers.BaseVector;
+import io.objectbox.flatbuffers.BooleanVector;
+import io.objectbox.flatbuffers.ByteVector;
+import io.objectbox.flatbuffers.Constants;
+import io.objectbox.flatbuffers.DoubleVector;
+import io.objectbox.flatbuffers.FlatBufferBuilder;
+import io.objectbox.flatbuffers.FloatVector;
+import io.objectbox.flatbuffers.IntVector;
+import io.objectbox.flatbuffers.LongVector;
+import io.objectbox.flatbuffers.ShortVector;
+import io.objectbox.flatbuffers.StringVector;
+import io.objectbox.flatbuffers.Struct;
+import io.objectbox.flatbuffers.Table;
+import io.objectbox.flatbuffers.UnionVector;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+/**
+ * The Sync server configuration used to configure a starting Sync Server.
+ */
+@SuppressWarnings("unused")
+public final class SyncServerOptions extends Table {
+  public static void ValidateVersion() { Constants.FLATBUFFERS_23_5_26(); }
+  public static SyncServerOptions getRootAsSyncServerOptions(ByteBuffer _bb) { return getRootAsSyncServerOptions(_bb, new SyncServerOptions()); }
+  public static SyncServerOptions getRootAsSyncServerOptions(ByteBuffer _bb, SyncServerOptions obj) { _bb.order(ByteOrder.LITTLE_ENDIAN); return (obj.__assign(_bb.getInt(_bb.position()) + _bb.position(), _bb)); }
+  public void __init(int _i, ByteBuffer _bb) { __reset(_i, _bb); }
+  public SyncServerOptions __assign(int _i, ByteBuffer _bb) { __init(_i, _bb); return this; }
+
+  /**
+   * URL of this Sync Server on which the Sync protocol is exposed (where the server "binds" to).
+   * This is typically a WebSockets URL, i.e. starting with "ws://" or "wss://" (with SSL enabled).
+   * Once running, Sync Clients can connect here.
+   */
+  public String url() { int o = __offset(4); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer urlAsByteBuffer() { return __vector_as_bytebuffer(4, 1); }
+  public ByteBuffer urlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 4, 1); }
+  /**
+   * A list of enabled authentication methods available to Sync Clients to login.
+   */
+  public io.objectbox.sync.Credentials authenticationMethods(int j) { return authenticationMethods(new io.objectbox.sync.Credentials(), j); }
+  public io.objectbox.sync.Credentials authenticationMethods(io.objectbox.sync.Credentials obj, int j) { int o = __offset(6); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int authenticationMethodsLength() { int o = __offset(6); return o != 0 ? __vector_len(o) : 0; }
+  public io.objectbox.sync.Credentials.Vector authenticationMethodsVector() { return authenticationMethodsVector(new io.objectbox.sync.Credentials.Vector()); }
+  public io.objectbox.sync.Credentials.Vector authenticationMethodsVector(io.objectbox.sync.Credentials.Vector obj) { int o = __offset(6); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+  /**
+   * Bit flags to configure the Sync Server that are also shared with Sync clients.
+   */
+  public long syncFlags() { int o = __offset(8); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Bit flags to configure the Sync Server.
+   */
+  public long syncServerFlags() { int o = __offset(10); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * The SSL certificate directory; SSL will be enabled if not empty.
+   * Expects the files cert.pem and key.pem present in this directory.
+   */
+  public String certificatePath() { int o = __offset(12); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer certificatePathAsByteBuffer() { return __vector_as_bytebuffer(12, 1); }
+  public ByteBuffer certificatePathInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 12, 1); }
+  /**
+   * By default (absent or zero given), this uses a hardware dependent default, e.g. 3 * CPU "cores"
+   */
+  public long workerThreads() { int o = __offset(14); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Once the maximum size is reached, old TX logs are deleted to stay below this limit.
+   * This is sometimes also called "history pruning" in the context of Sync.
+   * Absent or zero: no limit
+   */
+  public long historySizeMaxKb() { int o = __offset(16); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * Once the maximum size (historySizeMaxKb) is reached,
+   * old TX logs are deleted until this size target is reached (lower than the maximum size).
+   * Using this target size typically lowers the frequency of history pruning and thus may improve efficiency.
+   * If absent or zero, it defaults to historySizeMaxKb.
+   */
+  public long historySizeTargetKb() { int o = __offset(18); return o != 0 ? bb.getLong(o + bb_pos) : 0L; }
+  /**
+   * URL of the Admin (web server) to bind to.
+   * Once running, the user can open a browser to open the Admin web app.
+   */
+  public String adminUrl() { int o = __offset(20); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer adminUrlAsByteBuffer() { return __vector_as_bytebuffer(20, 1); }
+  public ByteBuffer adminUrlInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 20, 1); }
+  /**
+   * Number of worker threads used by the Admin web server.
+   */
+  public long adminThreads() { int o = __offset(22); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Enables cluster mode (requires the Cluster feature) and associates this cluster peer with the given ID.
+   * Cluster peers need to share the same ID to be in the same cluster.
+   */
+  public String clusterId() { int o = __offset(24); return o != 0 ? __string(o + bb_pos) : null; }
+  public ByteBuffer clusterIdAsByteBuffer() { return __vector_as_bytebuffer(24, 1); }
+  public ByteBuffer clusterIdInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 24, 1); }
+  /**
+   * List of other (remote) cluster peers to connect to.
+   */
+  public io.objectbox.sync.server.ClusterPeerConfig clusterPeers(int j) { return clusterPeers(new io.objectbox.sync.server.ClusterPeerConfig(), j); }
+  public io.objectbox.sync.server.ClusterPeerConfig clusterPeers(io.objectbox.sync.server.ClusterPeerConfig obj, int j) { int o = __offset(26); return o != 0 ? obj.__assign(__indirect(__vector(o) + j * 4), bb) : null; }
+  public int clusterPeersLength() { int o = __offset(26); return o != 0 ? __vector_len(o) : 0; }
+  public io.objectbox.sync.server.ClusterPeerConfig.Vector clusterPeersVector() { return clusterPeersVector(new io.objectbox.sync.server.ClusterPeerConfig.Vector()); }
+  public io.objectbox.sync.server.ClusterPeerConfig.Vector clusterPeersVector(io.objectbox.sync.server.ClusterPeerConfig.Vector obj) { int o = __offset(26); return o != 0 ? obj.__assign(__vector(o), 4, bb) : null; }
+  /**
+   * Bit flags to configure the cluster behavior of this sync server (aka cluster peer).
+   */
+  public long clusterFlags() { int o = __offset(28); return o != 0 ? (long)bb.getInt(o + bb_pos) & 0xFFFFFFFFL : 0L; }
+  /**
+   * Optional configuration for JWT (JSON Web Token) authentication.
+   */
+  public io.objectbox.sync.server.JwtConfig jwtConfig() { return jwtConfig(new io.objectbox.sync.server.JwtConfig()); }
+  public io.objectbox.sync.server.JwtConfig jwtConfig(io.objectbox.sync.server.JwtConfig obj) { int o = __offset(30); return o != 0 ? obj.__assign(__indirect(o + bb_pos), bb) : null; }
+  /**
+   * Credential types that are required for clients logging in.
+   */
+  public long requiredCredentials(int j) { int o = __offset(32); return o != 0 ? (long)bb.getInt(__vector(o) + j * 4) & 0xFFFFFFFFL : 0; }
+  public int requiredCredentialsLength() { int o = __offset(32); return o != 0 ? __vector_len(o) : 0; }
+  public IntVector requiredCredentialsVector() { return requiredCredentialsVector(new IntVector()); }
+  public IntVector requiredCredentialsVector(IntVector obj) { int o = __offset(32); return o != 0 ? obj.__assign(__vector(o), bb) : null; }
+  public ByteBuffer requiredCredentialsAsByteBuffer() { return __vector_as_bytebuffer(32, 4); }
+  public ByteBuffer requiredCredentialsInByteBuffer(ByteBuffer _bb) { return __vector_in_bytebuffer(_bb, 32, 4); }
+
+  public static int createSyncServerOptions(FlatBufferBuilder builder,
+                                            int urlOffset,
+                                            int authenticationMethodsOffset,
+                                            long syncFlags,
+                                            long syncServerFlags,
+                                            int certificatePathOffset,
+                                            long workerThreads,
+                                            long historySizeMaxKb,
+                                            long historySizeTargetKb,
+                                            int adminUrlOffset,
+                                            long adminThreads,
+                                            int clusterIdOffset,
+                                            int clusterPeersOffset,
+                                            long clusterFlags,
+                                            int jwtConfigOffset,
+                                            int requiredCredentialsOffset) {
+    builder.startTable(15);
+    SyncServerOptions.addHistorySizeTargetKb(builder, historySizeTargetKb);
+    SyncServerOptions.addHistorySizeMaxKb(builder, historySizeMaxKb);
+    SyncServerOptions.addRequiredCredentials(builder, requiredCredentialsOffset);
+    SyncServerOptions.addJwtConfig(builder, jwtConfigOffset);
+    SyncServerOptions.addClusterFlags(builder, clusterFlags);
+    SyncServerOptions.addClusterPeers(builder, clusterPeersOffset);
+    SyncServerOptions.addClusterId(builder, clusterIdOffset);
+    SyncServerOptions.addAdminThreads(builder, adminThreads);
+    SyncServerOptions.addAdminUrl(builder, adminUrlOffset);
+    SyncServerOptions.addWorkerThreads(builder, workerThreads);
+    SyncServerOptions.addCertificatePath(builder, certificatePathOffset);
+    SyncServerOptions.addSyncServerFlags(builder, syncServerFlags);
+    SyncServerOptions.addSyncFlags(builder, syncFlags);
+    SyncServerOptions.addAuthenticationMethods(builder, authenticationMethodsOffset);
+    SyncServerOptions.addUrl(builder, urlOffset);
+    return SyncServerOptions.endSyncServerOptions(builder);
+  }
+
+  public static void startSyncServerOptions(FlatBufferBuilder builder) { builder.startTable(15); }
+  public static void addUrl(FlatBufferBuilder builder, int urlOffset) { builder.addOffset(0, urlOffset, 0); }
+  public static void addAuthenticationMethods(FlatBufferBuilder builder, int authenticationMethodsOffset) { builder.addOffset(1, authenticationMethodsOffset, 0); }
+  public static int createAuthenticationMethodsVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startAuthenticationMethodsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addSyncFlags(FlatBufferBuilder builder, long syncFlags) { builder.addInt(2, (int) syncFlags, (int) 0L); }
+  public static void addSyncServerFlags(FlatBufferBuilder builder, long syncServerFlags) { builder.addInt(3, (int) syncServerFlags, (int) 0L); }
+  public static void addCertificatePath(FlatBufferBuilder builder, int certificatePathOffset) { builder.addOffset(4, certificatePathOffset, 0); }
+  public static void addWorkerThreads(FlatBufferBuilder builder, long workerThreads) { builder.addInt(5, (int) workerThreads, (int) 0L); }
+  public static void addHistorySizeMaxKb(FlatBufferBuilder builder, long historySizeMaxKb) { builder.addLong(6, historySizeMaxKb, 0L); }
+  public static void addHistorySizeTargetKb(FlatBufferBuilder builder, long historySizeTargetKb) { builder.addLong(7, historySizeTargetKb, 0L); }
+  public static void addAdminUrl(FlatBufferBuilder builder, int adminUrlOffset) { builder.addOffset(8, adminUrlOffset, 0); }
+  public static void addAdminThreads(FlatBufferBuilder builder, long adminThreads) { builder.addInt(9, (int) adminThreads, (int) 0L); }
+  public static void addClusterId(FlatBufferBuilder builder, int clusterIdOffset) { builder.addOffset(10, clusterIdOffset, 0); }
+  public static void addClusterPeers(FlatBufferBuilder builder, int clusterPeersOffset) { builder.addOffset(11, clusterPeersOffset, 0); }
+  public static int createClusterPeersVector(FlatBufferBuilder builder, int[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addOffset(data[i]); return builder.endVector(); }
+  public static void startClusterPeersVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static void addClusterFlags(FlatBufferBuilder builder, long clusterFlags) { builder.addInt(12, (int) clusterFlags, (int) 0L); }
+  public static void addJwtConfig(FlatBufferBuilder builder, int jwtConfigOffset) { builder.addOffset(13, jwtConfigOffset, 0); }
+  public static void addRequiredCredentials(FlatBufferBuilder builder, int requiredCredentialsOffset) { builder.addOffset(14, requiredCredentialsOffset, 0); }
+  public static int createRequiredCredentialsVector(FlatBufferBuilder builder, long[] data) { builder.startVector(4, data.length, 4); for (int i = data.length - 1; i >= 0; i--) builder.addInt((int) data[i]); return builder.endVector(); }
+  public static void startRequiredCredentialsVector(FlatBufferBuilder builder, int numElems) { builder.startVector(4, numElems, 4); }
+  public static int endSyncServerOptions(FlatBufferBuilder builder) {
+    int o = builder.endTable();
+    return o;
+  }
+  public static void finishSyncServerOptionsBuffer(FlatBufferBuilder builder, int offset) { builder.finish(offset); }
+  public static void finishSizePrefixedSyncServerOptionsBuffer(FlatBufferBuilder builder, int offset) { builder.finishSizePrefixed(offset); }
+
+  public static final class Vector extends BaseVector {
+    public Vector __assign(int _vector, int _element_size, ByteBuffer _bb) { __reset(_vector, _element_size, _bb); return this; }
+
+    public SyncServerOptions get(int j) { return get(new SyncServerOptions(), j); }
+    public SyncServerOptions get(SyncServerOptions obj, int j) {  return obj.__assign(__indirect(__element(j), bb), bb); }
+  }
+}
+
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/Branch.java b/objectbox-java/src/main/java/io/objectbox/tree/Branch.java
new file mode 100644
index 00000000..8b6e3463
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/tree/Branch.java
@@ -0,0 +1,144 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.tree;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * A branch within a {@link Tree}. May have {@link #branch(String[]) branches} or {@link #leaf(String[]) leaves}.
+ */
+@Experimental
+public class Branch {
+
+    private final Tree tree;
+    private final long id;
+
+    Branch(Tree tree, long id) {
+        this.tree = tree;
+        this.id = id;
+    }
+
+    public Tree getTree() {
+        return tree;
+    }
+
+    public long getId() {
+        return id;
+    }
+
+    /**
+     * Get the branch following the given path of child branches from this branch.
+     *
+     * @return null if no matching tree node was found
+     */
+    @Nullable
+    public Branch branch(String[] path) {
+        checkPath(path);
+        long branchId = nativeGetBranchId(tree.getHandle(), id, path);
+        if (branchId == 0) return null;
+        return new Branch(tree, branchId);
+    }
+
+    /**
+     * Get the branch following the given path of child branches from this branch.
+     *
+     * @return null if no matching tree node was found
+     */
+    @Nullable
+    public Branch branch(String pathString) {
+        checkNameOrPath(pathString);
+        String[] path = pathString.split(tree.getPathSeparatorRegex());
+        return branch(path);
+    }
+
+    /**
+     * Get the child branch directly attached to this branch with the given name.
+     *
+     * @return null if no matching tree node was found
+     */
+    @Nullable
+    public Branch branchChild(String name) {
+        String[] path = new String[]{name};
+        return branch(path);
+    }
+
+    /**
+     * Get the leaf following the given path of children from this branch.
+     *
+     * @return null if no matching tree node was found
+     */
+    @Nullable
+    public Leaf leaf(String[] path) {
+        checkPath(path);
+        LeafNode leafNode = nativeGetLeaf(tree.getHandle(), id, path);
+        if (leafNode == null) return null;
+        return new Leaf(leafNode);
+    }
+
+    /**
+     * Get the leaf following the given path of children from this branch.
+     *
+     * @return null if no matching tree node was found
+     */
+    @Nullable
+    public Leaf leaf(String pathString) {
+        checkNameOrPath(pathString);
+        String[] path = pathString.split(tree.getPathSeparatorRegex());
+        return leaf(path);
+    }
+
+    /**
+     * Get the child leaf directly attached to this branch with the given name.
+     *
+     * @return null if no matching tree node was found
+     */
+    @Nullable
+    public Leaf leafChild(String name) {
+        checkNameOrPath(name);
+        String[] path = new String[]{name};
+        return leaf(path);
+    }
+
+    private void checkNameOrPath(String name) {
+        //noinspection ConstantConditions Nullability annotations are not enforced.
+        if (name == null || name.length() == 0) {
+            throw new IllegalArgumentException("name/path must not be null or empty");
+        }
+    }
+
+    private void checkPath(String[] path) {
+        //noinspection ConstantConditions Nullability annotations are not enforced.
+        if (path == null || path.length == 0) {
+            throw new IllegalArgumentException("path must not be null or empty");
+        }
+    }
+
+    /**
+     * Get a data branch ID matching the path, starting at the given data {@code branchId}.
+     * If {@code branchId == 0}, it assumes there's only one data tree in the database.
+     */
+    private native long nativeGetBranchId(long treeHandle, long branchId, String[] path);
+
+    /**
+     * Get a data leaf matching the path, starting at the given data {@code branchId}.
+     * If {@code branchId == 0}, it assumes there's only one data tree in the database.
+     */
+    private native LeafNode nativeGetLeaf(long treeHandle, long branchId, String[] path);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java b/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java
new file mode 100644
index 00000000..c16a93ea
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/tree/Leaf.java
@@ -0,0 +1,204 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.tree;
+
+import java.nio.charset.StandardCharsets;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.model.PropertyType;
+
+/**
+ * A data leaf represents a data value in a {@link Tree} as a child of a {@link Branch}.
+ * Each data value has a specific type, e.g. an int or a String.
+ */
+@Experimental
+public class Leaf {
+
+    private final LeafNode node;
+
+    public Leaf(LeafNode node) {
+        this.node = node;
+    }
+
+    public long getId() {
+        return node.id;
+    }
+
+    public long getParentBranchId() {
+        return node.branchId;
+    }
+
+    public long getMetaId() {
+        return node.metaId;
+    }
+
+    /** See {@link PropertyType} for possible types (not all are used here). */
+    public short getValueType() {
+        return node.valueType;
+    }
+
+    public boolean isInt() {
+        return node.valueType == PropertyType.Long;
+    }
+
+    public boolean isDouble() {
+        return node.valueType == PropertyType.Double;
+    }
+
+    public boolean isString() {
+        return node.valueType == PropertyType.ByteVector;
+    }
+
+    public boolean isStringArray() {
+        return node.valueType == PropertyType.ShortVector;
+    }
+
+    private void verifyIsInt() {
+        if (!isInt()) throw new IllegalStateException("value is not integer (" + node.valueType + ")");
+    }
+
+    private void verifyIsDouble() {
+        if (!isDouble()) throw new IllegalStateException("value is not floating point (" + node.valueType + ")");
+    }
+
+    private void verifyIsString() {
+        if (!isString()) throw new IllegalStateException("value is not string (" + node.valueType + ")");
+    }
+
+    private void verifyIsStringArray() {
+        if (!isStringArray()) throw new IllegalStateException("value is not string array");
+    }
+
+    // valueInt
+    public long getInt() {
+        verifyIsInt();
+        return node.integerValue;
+    }
+
+    // valueDouble
+    public double getDouble() {
+        verifyIsDouble();
+        return node.floatingValue;
+    }
+
+    // valueString
+    @Nullable
+    public String getString() {
+        verifyIsString();
+        if (node.objectValue instanceof String) {
+            return (String) node.objectValue;
+        } else {
+            byte[] bytes = (byte[]) node.objectValue;
+            return new String(bytes, StandardCharsets.UTF_8);
+        }
+    }
+
+    // valueStrings
+    @Nullable
+    public String[] getStringArray() {
+        verifyIsStringArray();
+        return (String[]) node.objectValue;
+    }
+
+    @Nullable
+    public Long asInt() {
+        if (isInt()) return getInt();
+
+        if (isDouble()) {
+            return (long) getDouble();
+        }
+        if (isString()) {
+            String value = getString();
+            try {
+                return value != null ? Long.valueOf(value) : null;
+            } catch (NumberFormatException ignored) {
+                return null;
+            }
+        }
+
+        return null;
+    }
+
+    @Nullable
+    public Double asDouble() {
+        if (isDouble()) return getDouble();
+
+        if (isInt()) {
+            return (double) getInt();
+        }
+        if (isString()) {
+            String value = getString();
+            try {
+                return value != null ? Double.valueOf(value) : null;
+            } catch (NumberFormatException ignored) {
+                return null;
+            }
+        }
+
+        return null;
+    }
+
+    @Nullable
+    public String asString() {
+        if (isString()) return getString();
+
+        if (isInt()) {
+            return String.valueOf(getInt());
+        }
+        if (isDouble()) {
+            return String.valueOf(getDouble());
+        }
+        if (isStringArray()) {
+            String[] value = getStringArray();
+            if (value == null) return null;
+            return String.join(", ", value);
+        }
+
+        return null;
+    }
+
+    @Nullable
+    public String[] asStringArray() {
+        if (isStringArray()) return getStringArray();
+
+        String value = asString();
+        return value != null ? new String[]{value} : null;
+    }
+
+    public void setInt(long value) {
+        verifyIsInt();
+        node.integerValue = value;
+    }
+
+    public void setDouble(double value) {
+        verifyIsDouble();
+        node.floatingValue = value;
+    }
+
+    public void setString(@Nullable String value) {
+        verifyIsString();
+        node.objectValue = value;
+    }
+
+    public void setStringArray(@Nullable String[] value) {
+        verifyIsStringArray();
+        node.objectValue = value;
+    }
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java b/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java
new file mode 100644
index 00000000..fcb4215e
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/tree/LeafNode.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.tree;
+
+import io.objectbox.annotation.apihint.Experimental;
+
+/**
+ * (Potentially internal) value object created in our JNI layer to represent a leaf with all stored data.
+ * Note that only one of the value properties is actually set for any node.
+ */
+@Experimental
+public class LeafNode {
+    final public long id;
+    final public long branchId;
+    final public long metaId;
+
+    public long integerValue;
+    public double floatingValue;
+
+    /**
+     * One of String, byte[], String[]
+     */
+    public Object objectValue;
+
+    /**
+     * See {@link io.objectbox.model.PropertyType} for values.
+     * Attention: does not represent the type accurately yet:
+     * 1) Strings are Bytes, 2) all integer type are Long, 3) all FPs are Double.
+     */
+    public short valueType;
+
+    /**
+     * All-args constructor used by JNI (don't change, it's actually used).
+     */
+    public LeafNode(long id, long branchId, long metaId, long integerValue, double floatingValue, Object objectValue,
+                    short valueType) {
+        this.id = id;
+        this.branchId = branchId;
+        this.metaId = metaId;
+        this.integerValue = integerValue;
+        this.floatingValue = floatingValue;
+        this.objectValue = objectValue;
+        this.valueType = valueType;
+    }
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/Tree.java b/objectbox-java/src/main/java/io/objectbox/tree/Tree.java
new file mode 100644
index 00000000..29535883
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/tree/Tree.java
@@ -0,0 +1,453 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.tree;
+
+import java.io.Closeable;
+import java.util.concurrent.Callable;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.BoxStore;
+import io.objectbox.InternalAccess;
+import io.objectbox.Transaction;
+import io.objectbox.annotation.apihint.Experimental;
+import io.objectbox.model.PropertyType;
+
+/**
+ * A higher level tree API operating on branch and leaf nodes.
+ * Points to a root branch, can traverse child branches and read and write data in leafs.
+ * <p>
+ * Depends on a compatible tree model (entity types), which is matched by type and property names.
+ * E.g. names like "DataLeaf.valueString" are fixed and may not be changed.
+ * Adding properties to tree types is allowed.
+ * <p>
+ * Note there are TWO ways to work with tree data (both ways can be mixed):
+ * - Standard ObjectBox entity types with e.g. Box&lt;DataLeaf&gt;
+ * - Higher level tree API via this Tree class
+ * <p>
+ * To navigate in the tree, you typically start with {@link #getRoot()}, which returns a {@link Branch}.
+ * From one branch you can navigate to other branches and also {@link Leaf}s, which carry data attributes.
+ * <p>
+ * You can easily navigate the tree by using a path, which is either a string or a string array.
+ * A path refers to the names of the meta tree nodes, e.g. "Book.Author.Name".
+ * <p>
+ * If you already know the IDs, you can efficiently access branches, data leaves, and data values directly.
+ * <p>
+ * To access any data in the tree, you must use explicit transactions offer by methods such as
+ * {@link #runInTx(Runnable)}, {@link #runInReadTx(Runnable)}, {@link #callInTx(Callable)}, or
+ * {@link #callInReadTx(Callable)}.
+ */
+@SuppressWarnings("SameParameterValue")
+@Experimental
+public class Tree implements Closeable {
+
+    private long handle;
+    private final BoxStore store;
+    private long rootId;
+    private String pathSeparatorRegex = "\\.";
+
+    /**
+     * Create a tree instance for the given meta-branch root {@code uid}, or find a singular root if 0 is given.
+     */
+    public Tree(BoxStore store, String uid) {
+        this.store = store;
+        //noinspection ConstantConditions Nullability annotations are not enforced.
+        if (store == null) {
+            throw new IllegalArgumentException("store must not be null");
+        }
+        //noinspection ConstantConditions Nullability annotations are not enforced.
+        if (uid == null || uid.length() == 0) {
+            throw new IllegalArgumentException("uid must be 0 or not empty");
+        }
+        this.handle = nativeCreateWithUid(store.getNativeStore(), uid);
+    }
+
+    /**
+     * Create a tree instance for the given data-branch root ID.
+     */
+    public Tree(BoxStore store, long rootId) {
+        this.store = store;
+        this.rootId = rootId;
+        //noinspection ConstantConditions Nullability annotations are not enforced.
+        if (store == null) {
+            throw new IllegalArgumentException("store must not be null");
+        }
+        this.handle = nativeCreate(store.getNativeStore(), rootId);
+    }
+
+    long getHandle() {
+        return handle;
+    }
+
+    /**
+     * The path separator regex is used to split a string path into individual path names.
+     * Example: with the default separator, e.g. "Book.Author" becomes ["Book", "Author"].
+     */
+    public String getPathSeparatorRegex() {
+        return pathSeparatorRegex;
+    }
+
+    /** E.g. use "\\/" to change path strings to "Book/Author"; see {@link #getPathSeparatorRegex()} for details. */
+    public void setPathSeparatorRegex(String pathSeparatorRegex) {
+        this.pathSeparatorRegex = pathSeparatorRegex;
+    }
+
+    /**
+     * The root ID, which the tree was constructed with.
+     */
+    public long getRootId() {
+        return rootId;
+    }
+
+    public BoxStore getStore() {
+        return store;
+    }
+
+    /**
+     * Gets the root of the data tree.
+     */
+    public Branch getRoot() {
+        long dataBranchId = nativeGetRootId(handle);
+        return new Branch(this, dataBranchId);
+    }
+
+    /**
+     * Cleans up any (native) resources associated with this tree.
+     */
+    public void close() {
+        long handle = this.handle;
+        nativeDelete(handle);
+        this.handle = 0;
+    }
+
+    /**
+     * Similar to {@link BoxStore#runInTx(Runnable)}, but allows Tree functions.
+     */
+    public void runInTx(Runnable runnable) {
+        store.runInTx(createTxRunnable(runnable));
+    }
+
+    /**
+     * Similar to {@link BoxStore#runInReadTx(Runnable)}, but allows Tree functions.
+     */
+    public void runInReadTx(Runnable runnable) {
+        store.runInReadTx(createTxRunnable(runnable));
+    }
+
+    /**
+     * Similar to {@link BoxStore#callInReadTx(Callable)}, but allows Tree functions.
+     */
+    public <T> T callInTx(Callable<T> callable) throws Exception {
+        return store.callInTx(createTxCallable(callable));
+    }
+
+    /**
+     * Wraps any Exception thrown by the callable into a RuntimeException.
+     */
+    public <T> T callInTxNoThrow(Callable<T> callable) {
+        try {
+            return store.callInTx(createTxCallable(callable));
+        } catch (Exception e) {
+            throw new RuntimeException("Callable threw exception", e);
+        }
+    }
+
+    /**
+     * Similar to {@link BoxStore#callInReadTx(Callable)}, but allows Tree functions.
+     */
+    public <T> T callInReadTx(Callable<T> callable) {
+        return store.callInReadTx(createTxCallable(callable));
+    }
+
+    private Runnable createTxRunnable(Runnable runnable) {
+        return () -> {
+            Transaction tx = InternalAccess.getActiveTx(store);
+            boolean topLevel = nativeSetTransaction(handle, InternalAccess.getHandle(tx));
+            try {
+                runnable.run();
+            } finally {
+                if (topLevel) nativeClearTransaction(handle);
+            }
+        };
+    }
+
+    private <T> Callable<T> createTxCallable(Callable<T> callable) {
+        return () -> {
+            Transaction tx = InternalAccess.getActiveTx(store);
+            boolean topLevel = nativeSetTransaction(handle, InternalAccess.getHandle(tx));
+            try {
+                return callable.call();
+            } finally {
+                if (topLevel) nativeClearTransaction(handle);
+            }
+        };
+    }
+
+    /**
+     * Get the leaf for the given ID or null if no leaf exists with that ID.
+     */
+    @Nullable
+    public Leaf getLeaf(long id) {
+        LeafNode leafNode = nativeGetLeafById(handle, id);
+        if (leafNode == null) return null;
+        return new Leaf(leafNode);
+    }
+
+    /**
+     * Get data value for the given ID or null if no data leaf exists with that ID.
+     */
+    @Nullable
+    public String getString(long id) {
+        Leaf leaf = getLeaf(id);
+        return leaf != null ? leaf.asString() : null;
+    }
+
+    /**
+     * Get data value for the given ID or null if no data leaf exists with that ID.
+     */
+    @Nullable
+    public Long getInteger(long id) {
+        Leaf leaf = getLeaf(id);
+        return leaf != null ? leaf.asInt() : null;
+    }
+
+    /**
+     * Get data value for the given ID or null if no data leaf exists with that ID.
+     */
+    @Nullable
+    public Double getDouble(long id) {
+        Leaf leaf = getLeaf(id);
+        return leaf != null ? leaf.asDouble() : null;
+    }
+
+    /**
+     * Puts (persists) a branch in the metamodel.
+     */
+    public long putMetaBranch(long id, long parentBranchId, String name) {
+        return nativePutMetaBranch(handle, id, parentBranchId, name, null);
+    }
+
+    /**
+     * Puts (persists) a branch in the metamodel with an optional description.
+     */
+    public long putMetaBranch(long id, long parentBranchId, String name, @Nullable String description) {
+        return nativePutMetaBranch(handle, id, parentBranchId, name, description);
+    }
+
+    /**
+     * Puts (persists) several branches in the metamodel to create the given path from the root.
+     */
+    public long[] putMetaBranches(String[] path) {
+        return nativePutMetaBranches(handle, 0, path);
+    }
+
+    /**
+     * Puts (persists) several branches in the metamodel from the given parent ID (must be a meta branch).
+     */
+    public long[] putMetaBranches(long parentBranchId, String[] path) {
+        return nativePutMetaBranches(handle, parentBranchId, path);
+    }
+
+    /**
+     * Puts (persists) a data leaf in the metamodel (describes values).
+     */
+    public long putMetaLeaf(long id, long parentBranchId, String name, short valueType) {
+        return nativePutMetaLeaf(handle, id, parentBranchId, name, valueType, false, null);
+    }
+
+    /**
+     * Puts (persists) a data leaf in the metamodel (describes values).
+     */
+    public long putMetaLeaf(long id, long parentBranchId, String name, short valueType,
+                            boolean isUnsigned) {
+        return nativePutMetaLeaf(handle, id, parentBranchId, name, valueType, isUnsigned, null);
+    }
+
+    /**
+     * Puts (persists) a data leaf in the metamodel (describes values).
+     */
+    public long putMetaLeaf(long id, long parentBranchId, String name, short valueType,
+                            boolean isUnsigned, @Nullable String description) {
+        return nativePutMetaLeaf(handle, id, parentBranchId, name, valueType, isUnsigned, description);
+    }
+
+    /**
+     * Put a new or existing data branch
+     */
+    public long putBranch(long id, long parentBranchId, long metaId, @Nullable String uid) {
+        return nativePutBranch(handle, id, parentBranchId, metaId, uid);
+    }
+
+    /**
+     * Put a new (inserts) data branch
+     */
+    public long putBranch(long parentBranchId, long metaId, @Nullable String uid) {
+        return nativePutBranch(handle, 0, parentBranchId, metaId, uid);
+    }
+
+    /**
+     * Put a new (inserts) data branch
+     */
+    public long putBranch(long parentBranchId, long metaId) {
+        return nativePutBranch(handle, 0, parentBranchId, metaId, null);
+    }
+
+
+    /**
+     * Puts (persists) a data value (using a data leaf). If a data leaf exists at the given ID, it's overwritten.
+     *
+     * @param id             Existing ID or zero to insert a new data leaf.
+     * @param parentBranchId ID of the data branch, this data value belongs to.
+     * @param metaId         ID of the metadata leaf "describing" this data value.
+     * @param value          the actual data value.
+     * @return the ID of the put data leaf.
+     */
+    public long putValue(long id, long parentBranchId, long metaId, long value) {
+        return nativePutValueInteger(handle, id, parentBranchId, metaId, value);
+    }
+
+    /**
+     * Puts (inserts) a new data value (using a data leaf).
+     *
+     * @param parentBranchId ID of the data branch, this data value belongs to.
+     * @param metaId         ID of the metadata leaf "describing" this data value.
+     * @param value          the actual data value.
+     * @return the ID of the new data leaf.
+     */
+    public long putValue(long parentBranchId, long metaId, long value) {
+        return nativePutValueInteger(handle, 0, parentBranchId, metaId, value);
+    }
+
+    /**
+     * Puts (inserts) a new data value (using a data leaf).
+     *
+     * @param parentBranchId ID of the data branch, this data value belongs to.
+     * @param metaId         ID of the metadata leaf "describing" this data value.
+     * @param value          the actual data value.
+     * @return the ID of the new data leaf.
+     */
+    public long putValue(long parentBranchId, long metaId, double value) {
+        return nativePutValueFP(handle, 0, parentBranchId, metaId, value);
+    }
+
+    /**
+     * Puts (persists) a data value (using a data leaf). If a data leaf exists at the given ID, it's overwritten.
+     *
+     * @param id             Existing ID or zero to insert a new data leaf.
+     * @param parentBranchId ID of the data branch, this data value belongs to.
+     * @param metaId         ID of the metadata leaf "describing" this data value.
+     * @param value          the actual data value.
+     * @return the ID of the put data leaf.
+     */
+    public long putValue(long id, long parentBranchId, long metaId, double value) {
+        return nativePutValueFP(handle, id, parentBranchId, metaId, value);
+    }
+
+    /**
+     * Puts (persists) a data value (using a data leaf). If a data leaf exists at the given ID, it's overwritten.
+     *
+     * @param id             Existing ID or zero to insert a new data leaf.
+     * @param parentBranchId ID of the data branch, this data value belongs to.
+     * @param metaId         ID of the metadata leaf "describing" this data value.
+     * @param value          the actual data value.
+     * @return the ID of the put data leaf.
+     */
+    public long putValue(long id, long parentBranchId, long metaId, String value) {
+        return nativePutValueString(handle, id, parentBranchId, metaId, value);
+    }
+
+    /**
+     * Puts (inserts) a new data value (using a data leaf).
+     *
+     * @param parentBranchId ID of the data branch, this data value belongs to.
+     * @param metaId         ID of the metadata leaf "describing" this data value.
+     * @param value          the actual data value.
+     * @return the ID of the new data leaf.
+     */
+    public long putValue(long parentBranchId, long metaId, String value) {
+        return nativePutValueString(handle, 0, parentBranchId, metaId, value);
+    }
+
+    /**
+     * Puts (persists) a data leaf (containing a data value). If a data leaf exists with the same ID, it's overwritten.
+     *
+     * @return the ID of the put data leaf.
+     */
+    public long put(Leaf leaf) {
+        long id = leaf.getId();
+        long parentId = leaf.getParentBranchId();
+        long metaId = leaf.getMetaId();
+
+        switch (leaf.getValueType()) {
+            case PropertyType.Byte:
+            case PropertyType.Char:
+            case PropertyType.Short:
+            case PropertyType.Int:
+            case PropertyType.Long:
+                return nativePutValueInteger(handle, id, parentId, metaId, leaf.getInt());
+            case PropertyType.Float:
+            case PropertyType.Double:
+                return nativePutValueFP(handle, id, parentId, metaId, leaf.getDouble());
+            case PropertyType.ByteVector:
+            case PropertyType.String:
+                // Note: using getString() as it also converts byte[]
+                return nativePutValueString(handle, id, parentId, metaId, leaf.getString());
+            default:
+                throw new UnsupportedOperationException("Unsupported value type: " + leaf.getValueType());
+        }
+    }
+
+    /**
+     * Create a (Data)Tree instance for the given meta-branch root, or find a singular root if 0 is given.
+     */
+    static native long nativeCreate(long store, long rootId);
+
+    /**
+     * Not usable yet; TX is not aligned
+     */
+    static native long nativeCreateWithUid(long store, String uid);
+
+    static native void nativeDelete(long handle);
+
+    native boolean nativeSetTransaction(long handle, long txHandle);
+
+    native void nativeClearTransaction(long handle);
+
+    /**
+     * Get the root data branch ID.
+     */
+    native long nativeGetRootId(long handle);
+
+    native LeafNode nativeGetLeafById(long treeHandle, long leafId);
+
+    native long nativePutMetaBranch(long treeHandle, long id, long parentBranchId, String name,
+                                    @Nullable String description);
+
+    native long[] nativePutMetaBranches(long treeHandle, long parentBranchId, String[] path);
+
+    native long nativePutMetaLeaf(long treeHandle, long id, long parentBranchId, String name, short valueType,
+                                  boolean isUnsigned, @Nullable String description);
+
+    native long nativePutBranch(long treeHandle, long id, long parentBranchId, long metaId, @Nullable String uid);
+
+    native long nativePutValueInteger(long treeHandle, long id, long parentBranchId, long metaId, long value);
+
+    native long nativePutValueFP(long treeHandle, long id, long parentBranchId, long metaId, double value);
+
+    native long nativePutValueString(long treeHandle, long id, long parentBranchId, long metaId, @Nullable String value);
+
+}
diff --git a/objectbox-java/src/main/java/io/objectbox/tree/package-info.java b/objectbox-java/src/main/java/io/objectbox/tree/package-info.java
new file mode 100644
index 00000000..7fe6b05b
--- /dev/null
+++ b/objectbox-java/src/main/java/io/objectbox/tree/package-info.java
@@ -0,0 +1,23 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * APIs to interact with tree structures stored in ObjectBox.
+ */
+@ParametersAreNonnullByDefault
+package io.objectbox.tree;
+
+import javax.annotation.ParametersAreNonnullByDefault;
\ No newline at end of file
diff --git a/objectbox-java/src/main/resources/META-INF/proguard/objectbox-java.pro b/objectbox-java/src/main/resources/META-INF/proguard/objectbox-java.pro
index 69631b2e..37f73b81 100644
--- a/objectbox-java/src/main/resources/META-INF/proguard/objectbox-java.pro
+++ b/objectbox-java/src/main/resources/META-INF/proguard/objectbox-java.pro
@@ -19,6 +19,7 @@
     void setTargetId(long);
 }
 -keep class io.objectbox.relation.ToMany
+-keep class io.objectbox.tree.LeafNode
 
 -keep @interface io.objectbox.annotation.Entity
 
@@ -41,3 +42,5 @@
 
 # for essentials
 -dontwarn sun.misc.Unsafe
+# SpotBugs annotations
+-dontwarn edu.umd.cs.findbugs.annotations.SuppressFBWarnings
diff --git a/objectbox-java/src/web/objectbox-stylesheet.css b/objectbox-java/src/web/objectbox-stylesheet.css
new file mode 100644
index 00000000..a5a42aa6
--- /dev/null
+++ b/objectbox-java/src/web/objectbox-stylesheet.css
@@ -0,0 +1,61 @@
+/*
+CSS variables to override, taken from the default stylesheet generated in build/docs/javadoc/stylesheet.css
+They are also documented at https://docs.oracle.com/en/java/javase/21/javadoc/javadoc-css-themes.html
+*/
+:root {
+    /*!* body, block and code fonts *!*/
+    /*--body-font-family: 'DejaVu Sans', Arial, Helvetica, sans-serif;*/
+    /*--block-font-family: 'DejaVu Serif', Georgia, "Times New Roman", Times, serif;*/
+    /*--code-font-family: 'DejaVu Sans Mono', monospace;*/
+    /*!* Base font sizes for body and code elements *!*/
+    /*--body-font-size: 14px;*/
+    /*--code-font-size: 14px;*/
+    /*!* Text colors for body and block elements *!*/
+    /*--body-text-color: #353833;*/
+    /*--block-text-color: #474747;*/
+    /* Background colors for various structural elements */
+    /*--body-background-color: #ffffff;*/
+    /*--section-background-color: #f8f8f8;*/
+    /*--detail-background-color: #ffffff;*/
+    /* Colors for navigation bar and table captions */
+    --navbar-background-color: #17A6A6;
+    /*--navbar-text-color: #ffffff;*/
+    /* Background color for subnavigation and various headers */
+    /*--subnav-background-color: #dee3e9;*/
+    /* Background and text colors for selected tabs and navigation items */
+    --selected-background-color: #7DDC7D;
+    /*--selected-text-color: #253441;*/
+    /*--selected-link-color: #1f389c;*/
+    /* Background colors for generated tables */
+    /*--even-row-color: #ffffff;*/
+    /*--odd-row-color: #eeeeef;*/
+    /* Text color for page title */
+    /*--title-color: #2c4557;*/
+    /* Text colors for links */
+    /*--link-color: #4A6782;*/
+    --link-color-active: #E61955;
+    /* Snippet colors */
+    /*--snippet-background-color: #ebecee;*/
+    /*--snippet-text-color: var(--block-text-color);*/
+    /*--snippet-highlight-color: #f7c590;*/
+    /* Border colors for structural elements and user defined tables */
+    /*--border-color: #ededed;*/
+    /*--table-border-color: #000000;*/
+    /* Search input colors */
+    /*--search-input-background-color: #ffffff;*/
+    /*--search-input-text-color: #000000;*/
+    /*--search-input-placeholder-color: #909090;*/
+    /* Highlight color for active search tag target */
+    /*--search-tag-highlight-color: #ffff00;*/
+    /* Adjustments for icon and active background colors of copy-to-clipboard buttons */
+    /*--copy-icon-brightness: 100%;*/
+    /*--copy-button-background-color-active: rgba(168, 168, 176, 0.3);*/
+    /* Colors for invalid tag notifications */
+    /*--invalid-tag-background-color: #ffe6e6;*/
+    /*--invalid-tag-text-color: #000000;*/
+}
+
+/* Make code blocks scroll instead of stick out on small width */
+pre {
+    overflow-x: auto;
+}
diff --git a/objectbox-java/src/web/overview.html b/objectbox-java/src/web/overview.html
new file mode 100644
index 00000000..f2ff5577
--- /dev/null
+++ b/objectbox-java/src/web/overview.html
@@ -0,0 +1,16 @@
+<HTML>
+<BODY>
+<p>
+    Welcome to the Java API docs for <a href="https://objectbox.io">ObjectBox</a>, the super-fast database for objects.
+</p>
+<p>
+    The <b>main documentation</b> is available at <a href="https://docs.objectbox.io">docs.objectbox.io</a>, including a
+    <a href="https://docs.objectbox.io/getting-started">getting started guide</a>.
+</p>
+<p>
+    GitHub links: <a href="https://github.com/objectbox/objectbox-java">ObjectBox Java SDK</a>,
+    <a href="https://github.com/objectbox/objectbox-examples">Examples for Java, Kotlin and Android</a>
+</p>
+
+</BODY>
+</HTML>
\ No newline at end of file
diff --git a/objectbox-kotlin/build.gradle b/objectbox-kotlin/build.gradle
deleted file mode 100644
index dfe243da..00000000
--- a/objectbox-kotlin/build.gradle
+++ /dev/null
@@ -1,75 +0,0 @@
-buildscript {
-    ext.javadocDir = "$buildDir/docs/javadoc"
-}
-
-apply plugin: 'kotlin'
-apply plugin: 'org.jetbrains.dokka'
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-// Produce Java 8 byte code, would default to Java 6.
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-}
-
-dokka {
-    outputFormat = 'html'
-    outputDirectory = javadocDir
-
-    // Fix "Can't find node by signature": have to manually point to dependencies.
-    // https://github.com/Kotlin/dokka/wiki/faq#dokka-complains-about-cant-find-node-by-signature-
-    configuration{
-        externalDocumentationLink {
-            // Point to web javadoc for objectbox-java packages.
-            url = new URL("https://objectbox.io/docfiles/java/current/")
-            // Note: Using JDK 9+ package-list is now called element-list.
-            packageListUrl = new URL(url, "element-list")
-        }
-    }
-}
-
-task javadocJar(type: Jar, dependsOn: dokka) {
-    archiveClassifier.set('javadoc')
-    from "$javadocDir"
-}
-
-task sourcesJar(type: Jar) {
-    archiveClassifier.set('sources')
-    from sourceSets.main.allSource
-}
-
-artifacts {
-    // java plugin adds jar.
-    archives javadocJar
-    archives sourcesJar
-}
-
-dependencies {
-    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    api project(':objectbox-java')
-}
-
-
-uploadArchives {
-    repositories {
-        mavenDeployer {
-            // Basic definitions are defined in root project
-            pom.project {
-                name 'ObjectBox Kotlin'
-                description 'ObjectBox is a fast NoSQL database for Objects'
-
-                licenses {
-                    license {
-                        name 'The Apache Software License, Version 2.0'
-                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-                        distribution 'repo'
-                    }
-                }
-            }
-        }
-    }
-}
\ No newline at end of file
diff --git a/objectbox-kotlin/build.gradle.kts b/objectbox-kotlin/build.gradle.kts
new file mode 100644
index 00000000..a7502d54
--- /dev/null
+++ b/objectbox-kotlin/build.gradle.kts
@@ -0,0 +1,79 @@
+
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
+
+plugins {
+    alias(libs.plugins.kotlin.jvm)
+    id("objectbox.dokka-conventions")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+kotlin {
+    compilerOptions {
+        // Produce Java 8 byte code, would default to Java 6
+        jvmTarget.set(JvmTarget.JVM_1_8)
+
+        // Allow consumers of this library to use the oldest possible Kotlin compiler and standard libraries.
+        // https://kotlinlang.org/docs/compatibility-modes.html
+        // https://kotlinlang.org/docs/kotlin-evolution-principles.html#compatibility-tools
+
+        // Prevents using newer language features, sets this as the Kotlin version in produced metadata. So consumers
+        // can compile this with a Kotlin compiler down to one minor version before this.
+        // Pick the oldest not deprecated version.
+        languageVersion.set(KotlinVersion.KOTLIN_2_2)
+        // Prevents using newer APIs from the Kotlin standard library. So consumers can run this library with a Kotlin
+        // standard library down to this version.
+        // Pick the oldest not deprecated version.
+        apiVersion.set(KotlinVersion.KOTLIN_2_2)
+        // Depend on the oldest compatible Kotlin standard libraries (by default the Kotlin plugin coerces it to the one
+        // matching its version). So consumers can safely use this or any later Kotlin standard library.
+        // Pick the first release matching the versions above.
+        // Note: when changing, also update coroutines dependency version (as this does not set that).
+        coreLibrariesVersion = "2.2.0"
+    }
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    group = "build"
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+dependencies {
+    // Note: compileOnly so consumers do not depend on the coroutines library unless they manually
+    // add it.
+    compileOnly(libs.kotlin.coroutines.core.compat)
+
+    api(project(":objectbox-java"))
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxKotlin = "objectboxKotlin"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxKotlin) {
+            artifactId = "objectbox-kotlin"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            // Note: the javadocJar task is created by the objectbox.dokka-conventions plugin
+            artifact(tasks.named("javadocJar"))
+
+            pom {
+                name.set("ObjectBox Kotlin API")
+                description.set("ObjectBox is a fast NoSQL database for Objects")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxKotlin])
+}
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt
new file mode 100644
index 00000000..6b3feda3
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Box.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2021-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.kotlin
+
+import io.objectbox.Box
+import io.objectbox.query.Query
+import io.objectbox.query.QueryBuilder
+
+
+/**
+ * Note: new code should use the [Box.query] functions directly, including the new query API.
+ *
+ * Allows building a query for this Box instance with a call to [build][QueryBuilder.build] to return a [Query] instance.
+ *
+ * ```
+ * val query = box.query {
+ *     equal(Entity_.property, value)
+ * }
+ * ```
+ */
+@Deprecated("New code should use query(queryCondition).build() instead.")
+inline fun <T> Box<T>.query(block: QueryBuilder<T>.() -> Unit): Query<T> {
+    val builder = query()
+    block(builder)
+    return builder.build()
+}
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt
new file mode 100644
index 00000000..1385a219
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/BoxStore.kt
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.kotlin
+
+import io.objectbox.Box
+import io.objectbox.BoxStore
+import kotlinx.coroutines.asCoroutineDispatcher
+import java.util.concurrent.Callable
+import java.util.concurrent.ThreadFactory
+import kotlin.coroutines.resume
+import kotlin.coroutines.resumeWithException
+import kotlin.coroutines.suspendCoroutine
+import kotlin.reflect.KClass
+
+
+/** Shortcut for `BoxStore.boxFor(Entity::class.java)`. */
+inline fun <reified T> BoxStore.boxFor(): Box<T> = boxFor(T::class.java)
+
+/** Shortcut for `BoxStore.boxFor(Entity::class.java)`. */
+@Suppress("NOTHING_TO_INLINE")
+inline fun <T : Any> BoxStore.boxFor(clazz: KClass<T>): Box<T> = boxFor(clazz.java)
+
+/**
+ * Wraps [BoxStore.callInTxAsync] in a coroutine that suspends until the transaction has completed.
+ * Likewise, on success the return value of the given [callable] is returned, on failure an exception is thrown.
+ *
+ * Note that even if the coroutine is cancelled the callable is always executed.
+ *
+ * The callable (and transaction) is submitted to the ObjectBox internal thread pool.
+ */
+suspend fun <V : Any> BoxStore.awaitCallInTx(callable: Callable<V?>): V? {
+    return suspendCoroutine { continuation ->
+        callInTxAsync(callable) { result, error ->
+            if (error != null) {
+                continuation.resumeWithException(error)
+            } else {
+                continuation.resume(result)
+            }
+        }
+    }
+}
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newCachedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware cached thread pool
+ * @see BoxStore.newCachedThreadPoolExecutor
+ */
+fun BoxStore.newCachedThreadPoolDispatcher() = newCachedThreadPoolExecutor().asCoroutineDispatcher()
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newCachedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware cached thread pool
+ * @see BoxStore.newCachedThreadPoolExecutor
+ */
+fun BoxStore.newCachedThreadPoolDispatcher(threadFactory: ThreadFactory) =
+    newCachedThreadPoolExecutor(threadFactory).asCoroutineDispatcher()
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newFixedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware fixed thread pool
+ * @see BoxStore.newFixedThreadPoolExecutor
+ */
+fun BoxStore.newFixedThreadPoolDispatcher(nThreads: Int) =
+    newFixedThreadPoolExecutor(nThreads).asCoroutineDispatcher()
+
+/**
+ * Creates a coroutine dispatcher backed by a thread pool created with [BoxStore.newFixedThreadPoolExecutor] that
+ * automatically cleans up thread-local ObjectBox resources after each task.
+ *
+ * @return a [kotlinx.coroutines.CoroutineDispatcher] backed by an ObjectBox-aware fixed thread pool
+ * @see BoxStore.newFixedThreadPoolExecutor
+ */
+fun BoxStore.newFixedThreadPoolDispatcher(nThreads: Int, threadFactory: ThreadFactory) =
+    newFixedThreadPoolExecutor(nThreads, threadFactory).asCoroutineDispatcher()
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt
new file mode 100644
index 00000000..b2d77c53
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Flow.kt
@@ -0,0 +1,42 @@
+package io.objectbox.kotlin
+
+import io.objectbox.BoxStore
+import io.objectbox.query.Query
+import io.objectbox.reactive.SubscriptionBuilder
+import kotlinx.coroutines.channels.awaitClose
+import kotlinx.coroutines.channels.trySendBlocking
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.callbackFlow
+
+
+/**
+ * Like [SubscriptionBuilder.observer], but emits data changes to the returned flow.
+ * Automatically cancels the subscription when the flow is canceled.
+ *
+ * For example to create a flow to listen to all changes to a box:
+ * ```
+ * store.subscribe(TestEntity::class.java).toFlow()
+ * ```
+ *
+ * Or to get the latest query results on any changes to a box:
+ * ```
+ * box.query().subscribe().toFlow()
+ * ```
+ */
+fun <T> SubscriptionBuilder<T>.toFlow(): Flow<T> = callbackFlow {
+    val subscription = this@toFlow.observer {
+            trySendBlocking(it)
+        }
+    awaitClose { subscription.cancel() }
+}
+
+/**
+ * Shortcut for `BoxStore.subscribe(forClass).toFlow()`, see [BoxStore.subscribe] and [toFlow] for
+ * details.
+ */
+fun <T> BoxStore.flow(forClass: Class<T>): Flow<Class<T>> = this.subscribe(forClass).toFlow()
+
+/**
+ * Shortcut for `query.subscribe().toFlow()`, see [Query.subscribe] and [toFlow] for details.
+ */
+fun <T> Query<T>.flow(): Flow<MutableList<T>> = this@flow.subscribe().toFlow()
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt
new file mode 100644
index 00000000..246b7356
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Property.kt
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:Suppress("unused") // Public API.
+
+package io.objectbox.kotlin
+
+import io.objectbox.Property
+import io.objectbox.query.PropertyQueryCondition
+import java.util.*
+
+
+// Boolean
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: Boolean): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+infix fun <T> Property<T>.notEqual(value: Boolean): PropertyQueryCondition<T> {
+    return notEqual(value)
+}
+
+// Short
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: Short): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+infix fun <T> Property<T>.notEqual(value: Short): PropertyQueryCondition<T> {
+    return notEqual(value)
+}
+
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: Short): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: Short): PropertyQueryCondition<T> {
+    return less(value)
+}
+
+// Int
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: Int): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+infix fun <T> Property<T>.notEqual(value: Int): PropertyQueryCondition<T> {
+    return notEqual(value)
+}
+
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: Int): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: Int): PropertyQueryCondition<T> {
+    return less(value)
+}
+
+// IntArray
+/** Creates an "IN (..., ..., ...)" condition for this property. */
+infix fun <T> Property<T>.oneOf(value: IntArray): PropertyQueryCondition<T> {
+    return oneOf(value)
+}
+
+/** Creates a "NOT IN (..., ..., ...)" condition for this property. */
+infix fun <T> Property<T>.notOneOf(value: IntArray): PropertyQueryCondition<T> {
+    return notOneOf(value)
+}
+
+// Long
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: Long): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+infix fun <T> Property<T>.notEqual(value: Long): PropertyQueryCondition<T> {
+    return notEqual(value)
+}
+
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: Long): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: Long): PropertyQueryCondition<T> {
+    return less(value)
+}
+
+// LongArray
+/** Creates an "IN (..., ..., ...)" condition for this property. */
+infix fun <T> Property<T>.oneOf(value: LongArray): PropertyQueryCondition<T> {
+    return oneOf(value)
+}
+
+/** Creates a "NOT IN (..., ..., ...)" condition for this property. */
+infix fun <T> Property<T>.notOneOf(value: LongArray): PropertyQueryCondition<T> {
+    return notOneOf(value)
+}
+
+// Double
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: Double): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: Double): PropertyQueryCondition<T> {
+    return less(value)
+}
+
+// Date
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: Date): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+infix fun <T> Property<T>.notEqual(value: Date): PropertyQueryCondition<T> {
+    return notEqual(value)
+}
+
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: Date): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: Date): PropertyQueryCondition<T> {
+    return less(value)
+}
+
+// String
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: String): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "not equal ('&lt;&gt;')" condition for this property. */
+infix fun <T> Property<T>.notEqual(value: String): PropertyQueryCondition<T> {
+    return notEqual(value)
+}
+
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: String): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: String): PropertyQueryCondition<T> {
+    return less(value)
+}
+
+infix fun <T> Property<T>.contains(value: String): PropertyQueryCondition<T> {
+    return contains(value)
+}
+
+infix fun <T> Property<T>.startsWith(value: String): PropertyQueryCondition<T> {
+    return startsWith(value)
+}
+
+infix fun <T> Property<T>.endsWith(value: String): PropertyQueryCondition<T> {
+    return endsWith(value)
+}
+
+// Array<String>
+/** Creates an "IN (..., ..., ...)" condition for this property. */
+infix fun <T> Property<T>.oneOf(value: Array<String>): PropertyQueryCondition<T> {
+    return oneOf(value)
+}
+
+// ByteArray
+/** Creates an "equal ('=')" condition for this property. */
+infix fun <T> Property<T>.equal(value: ByteArray): PropertyQueryCondition<T> {
+    return equal(value)
+}
+
+/** Creates a "greater than ('&gt;')" condition for this property. */
+infix fun <T> Property<T>.greater(value: ByteArray): PropertyQueryCondition<T> {
+    return greater(value)
+}
+
+/** Creates a "less than ('&lt;')" condition for this property. */
+infix fun <T> Property<T>.less(value: ByteArray): PropertyQueryCondition<T> {
+    return less(value)
+}
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt
new file mode 100644
index 00000000..af958d45
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/PropertyQueryCondition.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.kotlin
+
+import io.objectbox.query.PropertyQueryCondition
+import io.objectbox.query.QueryCondition
+
+
+/**
+ * Assigns an alias to this condition that can later be used with the [io.objectbox.query.Query] setParameter methods.
+ */
+infix fun <T> PropertyQueryCondition<T>.alias(name: String): QueryCondition<T> {
+    return alias(name)
+}
\ No newline at end of file
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Extensions.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt
similarity index 69%
rename from objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Extensions.kt
rename to objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt
index 8b01fb31..402f0e2a 100644
--- a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/Extensions.kt
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryBuilder.kt
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2021 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,41 +14,25 @@
  * limitations under the License.
  */
 
-@file:Suppress("unused") // tested in integration test project
-
 package io.objectbox.kotlin
 
-import io.objectbox.Box
-import io.objectbox.BoxStore
 import io.objectbox.Property
-import io.objectbox.query.Query
 import io.objectbox.query.QueryBuilder
-import io.objectbox.relation.ToMany
-import kotlin.reflect.KClass
-
-/** Shortcut for `BoxStore.boxFor(Entity::class.java)`. */
-inline fun <reified T> BoxStore.boxFor(): Box<T> = boxFor(T::class.java)
 
-/** Shortcut for `BoxStore.boxFor(Entity::class.java)`. */
-@Suppress("NOTHING_TO_INLINE")
-inline fun <T : Any> BoxStore.boxFor(clazz: KClass<T>): Box<T> = boxFor(clazz.java)
 
 /** An alias for the "in" method, which is a reserved keyword in Kotlin. */
-inline fun <reified T> QueryBuilder<T>.inValues(property: Property<T>, values: LongArray): QueryBuilder<T>
-        = `in`(property, values)
+inline fun <reified T> QueryBuilder<T>.inValues(property: Property<T>, values: LongArray): QueryBuilder<T> =
+    `in`(property, values)
 
 /** An alias for the "in" method, which is a reserved keyword in Kotlin. */
-inline fun <reified T> QueryBuilder<T>.inValues(property: Property<T>, values: IntArray): QueryBuilder<T>
-        = `in`(property, values)
+inline fun <reified T> QueryBuilder<T>.inValues(property: Property<T>, values: IntArray): QueryBuilder<T> =
+    `in`(property, values)
 
 /** An alias for the "in" method, which is a reserved keyword in Kotlin. */
-inline fun <reified T> QueryBuilder<T>.inValues(property: Property<T>, values: Array<String>): QueryBuilder<T>
-        = `in`(property, values)
-
-/** An alias for the "in" method, which is a reserved keyword in Kotlin. */
-inline fun <reified T> QueryBuilder<T>.inValues(property: Property<T>, values: Array<String>,
-                                                stringOrder: QueryBuilder.StringOrder): QueryBuilder<T>
-        = `in`(property, values, stringOrder)
+inline fun <reified T> QueryBuilder<T>.inValues(
+    property: Property<T>, values: Array<String>,
+    stringOrder: QueryBuilder.StringOrder
+): QueryBuilder<T> = `in`(property, values, stringOrder)
 
 // Shortcuts for Short
 
@@ -67,11 +51,21 @@ inline fun <reified T> QueryBuilder<T>.less(property: Property<T>, value: Short)
     return less(property, value.toLong())
 }
 
+/** Shortcut for [lessOrEqual(property, value.toLong())][QueryBuilder.lessOrEqual] */
+inline fun <reified T> QueryBuilder<T>.lessOrEqual(property: Property<T>, value: Short): QueryBuilder<T> {
+    return lessOrEqual(property, value.toLong())
+}
+
 /** Shortcut for [greater(property, value.toLong())][QueryBuilder.greater] */
 inline fun <reified T> QueryBuilder<T>.greater(property: Property<T>, value: Short): QueryBuilder<T> {
     return greater(property, value.toLong())
 }
 
+/** Shortcut for [greaterOrEqual(property, value.toLong())][QueryBuilder.greaterOrEqual] */
+inline fun <reified T> QueryBuilder<T>.greaterOrEqual(property: Property<T>, value: Short): QueryBuilder<T> {
+    return greaterOrEqual(property, value.toLong())
+}
+
 /** Shortcut for [between(property, value1.toLong(), value2.toLong())][QueryBuilder.between] */
 inline fun <reified T> QueryBuilder<T>.between(property: Property<T>, value1: Short, value2: Short): QueryBuilder<T> {
     return between(property, value1.toLong(), value2.toLong())
@@ -94,11 +88,21 @@ inline fun <reified T> QueryBuilder<T>.less(property: Property<T>, value: Int):
     return less(property, value.toLong())
 }
 
+/** Shortcut for [lessOrEqual(property, value.toLong())][QueryBuilder.lessOrEqual] */
+inline fun <reified T> QueryBuilder<T>.lessOrEqual(property: Property<T>, value: Int): QueryBuilder<T> {
+    return lessOrEqual(property, value.toLong())
+}
+
 /** Shortcut for [greater(property, value.toLong())][QueryBuilder.greater] */
 inline fun <reified T> QueryBuilder<T>.greater(property: Property<T>, value: Int): QueryBuilder<T> {
     return greater(property, value.toLong())
 }
 
+/** Shortcut for [greaterOrEqual(property, value.toLong())][QueryBuilder.greaterOrEqual] */
+inline fun <reified T> QueryBuilder<T>.greaterOrEqual(property: Property<T>, value: Int): QueryBuilder<T> {
+    return greaterOrEqual(property, value.toLong())
+}
+
 /** Shortcut for [between(property, value1.toLong(), value2.toLong())][QueryBuilder.between] */
 inline fun <reified T> QueryBuilder<T>.between(property: Property<T>, value1: Int, value2: Int): QueryBuilder<T> {
     return between(property, value1.toLong(), value2.toLong())
@@ -116,42 +120,22 @@ inline fun <reified T> QueryBuilder<T>.less(property: Property<T>, value: Float)
     return less(property, value.toDouble())
 }
 
+/** Shortcut for [lessOrEqual(property, value.toDouble())][QueryBuilder.lessOrEqual] */
+inline fun <reified T> QueryBuilder<T>.lessOrEqual(property: Property<T>, value: Float): QueryBuilder<T> {
+    return lessOrEqual(property, value.toDouble())
+}
+
 /** Shortcut for [greater(property, value.toDouble())][QueryBuilder.greater] */
 inline fun <reified T> QueryBuilder<T>.greater(property: Property<T>, value: Float): QueryBuilder<T> {
     return greater(property, value.toDouble())
 }
 
+/** Shortcut for [greaterOrEqual(property, value.toDouble())][QueryBuilder.greaterOrEqual] */
+inline fun <reified T> QueryBuilder<T>.greaterOrEqual(property: Property<T>, value: Float): QueryBuilder<T> {
+    return greaterOrEqual(property, value.toDouble())
+}
+
 /** Shortcut for [between(property, value1.toDouble(), value2.toDouble())][QueryBuilder.between] */
 inline fun <reified T> QueryBuilder<T>.between(property: Property<T>, value1: Float, value2: Float): QueryBuilder<T> {
     return between(property, value1.toDouble(), value2.toDouble())
 }
-
-/**
- * Allows building a query for this Box instance with a call to [build][QueryBuilder.build] to return a [Query] instance.
- * ```
- * val query = box.query {
- *     equal(Entity_.property, value)
- * }
- * ```
- */
-inline fun <T> Box<T>.query(block: QueryBuilder<T>.() -> Unit) : Query<T> {
-    val builder = query()
-    block(builder)
-    return builder.build()
-}
-
-/**
- * Allows making changes (adding and removing entities) to this ToMany with a call to
- * [apply][ToMany.applyChangesToDb] the changes to the database.
- * Can [reset][ToMany.reset] the ToMany before making changes.
- * ```
- * toMany.applyChangesToDb {
- *     add(entity)
- * }
- * ```
- */
-inline fun <T> ToMany<T>.applyChangesToDb(resetFirst: Boolean = false, body: ToMany<T>.() -> Unit) {
-    if (resetFirst) reset()
-    body()
-    applyChangesToDb()
-}
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt
new file mode 100644
index 00000000..2f045924
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/QueryCondition.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.kotlin
+
+import io.objectbox.query.QueryCondition
+
+
+/**
+ * Combines the left hand side condition using AND with the right hand side condition.
+ *
+ * @see or
+ */
+infix fun <T> QueryCondition<T>.and(queryCondition: QueryCondition<T>): QueryCondition<T> {
+    return and(queryCondition)
+}
+
+/**
+ * Combines the left hand side condition using OR with the right hand side condition.
+ *
+ * @see and
+ */
+infix fun <T> QueryCondition<T>.or(queryCondition: QueryCondition<T>): QueryCondition<T> {
+    return or(queryCondition)
+}
\ No newline at end of file
diff --git a/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt
new file mode 100644
index 00000000..e7ec349f
--- /dev/null
+++ b/objectbox-kotlin/src/main/kotlin/io/objectbox/kotlin/ToMany.kt
@@ -0,0 +1,36 @@
+/*
+ * Copyright 2021 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.kotlin
+
+import io.objectbox.relation.ToMany
+
+/**
+ * Allows making changes (adding and removing entities) to this ToMany with a call to
+ * [apply][ToMany.applyChangesToDb] the changes to the database.
+ * Can [reset][ToMany.reset] the ToMany before making changes.
+ * ```
+ * toMany.applyChangesToDb {
+ *     add(entity)
+ * }
+ * ```
+ */
+@Suppress("unused") // Tested in integration tests
+inline fun <T> ToMany<T>.applyChangesToDb(resetFirst: Boolean = false, body: ToMany<T>.() -> Unit) {
+    if (resetFirst) reset()
+    body()
+    applyChangesToDb()
+}
diff --git a/objectbox-meshsync-android/README.md b/objectbox-meshsync-android/README.md
new file mode 100644
index 00000000..c81a62c4
--- /dev/null
+++ b/objectbox-meshsync-android/README.md
@@ -0,0 +1,53 @@
+# ObjectBox Mesh Sync for Android
+
+Adds peer-to-peer (P2P) mesh synchronization between ObjectBox Sync clients on Android, without a
+central server, using [Google Nearby Connections](https://developers.google.com/nearby/connections/overview).
+
+This is a plain (no native code, single variant) Android library that apps add **in addition** to the
+Sync variant of the ObjectBox Android library (e.g. `objectbox-sync-android`), which contains the native
+mesh sync implementation. Keeping it separate avoids multiplying the variants of the main Android library
+(basic/sync × with/without Admin) and keeps the Nearby dependency out of apps that don't use mesh sync.
+
+What this library provides:
+
+- `AndroidMeshSync.createConfig(context, meshId)` creating a `MeshConfig` (see `objectbox-java`) with the
+  Nearby Connections mesh network attached, to pass to `SyncBuilder.mesh()`.
+- The permissions that may be required by Nearby Connections, merged into the app manifest 
+  (see [AndroidManifest.xml](src/main/AndroidManifest.xml)).
+- The `play-services-nearby` dependency.
+
+## Permissions
+
+Note that not all permissions this library adds may be required. Depending on a device's Android SDK
+version and your app's needs, only some of them may actually be necessary. For example, location 
+permissions are typically not required for Nearby Connections on recent Android releases.
+
+To remove them as needed, use [merge rule markers](https://developer.android.com/build/manage-manifests) 
+in your app's manifest, for example:
+
+```xml
+<uses-permission
+    android:name="android.permission.ACCESS_COARSE_LOCATION"
+    tools:node="remove" />
+<uses-permission
+    android:name="android.permission.ACCESS_FINE_LOCATION"
+    tools:node="remove" />
+```
+
+Also note that your app must [request any dangerous (runtime) permissions](https://developer.android.com/training/permissions/requesting) 
+at runtime when needed. This library provides a [MeshSyncPermissions](src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt)
+helper class to request the permissions included by default.
+
+## Usage
+
+```kotlin
+val meshConfig: MeshConfig = AndroidMeshSync.createConfig(context, "example.myapp.mesh")
+
+val syncClient: SyncClient = Sync.client(boxStore)
+        .url(SYNC_SERVER_URL)
+        .credentials(credentials)
+        .mesh(meshConfig)
+        .buildAndStart()
+
+val mesh: MeshSync? = syncClient.getMesh() // state, connected peer count, stats
+```
diff --git a/objectbox-meshsync-android/build.gradle.kts b/objectbox-meshsync-android/build.gradle.kts
new file mode 100644
index 00000000..1d5b228d
--- /dev/null
+++ b/objectbox-meshsync-android/build.gradle.kts
@@ -0,0 +1,161 @@
+import org.gradle.kotlin.dsl.support.uppercaseFirstChar
+
+plugins {
+    alias(libs.plugins.android.library)
+    id("objectbox.publishing-conventions")
+}
+
+val flavorAdminExcluded = "adminExcluded"
+val flavorAdminIncluded = "adminIncluded"
+// Note: build variant names also match names of created components
+val buildTypeRelease = "release"
+val variantAdminExcludedRelease = "${flavorAdminExcluded}${buildTypeRelease.uppercaseFirstChar()}"
+val variantAdminIncludedRelease = "${flavorAdminIncluded}${buildTypeRelease.uppercaseFirstChar()}"
+
+android {
+    namespace = "io.objectbox.meshsync.android"
+    // Note: increasing compile SDK also signals this library is compatible with any changes in that
+    // API level, see "behavior changes" for each Android version at https://developer.android.com/about/versions
+    compileSdk = 35 // Android 15 (Vanilla Ice Cream)
+
+    defaultConfig {
+        minSdk = 21 // Android 5.0 (Lollipop), like objectbox-android
+
+        // Dependencies: objectbox-android also has a "database" dimension,
+        // always pick its "sync" flavor.
+        missingDimensionStrategy("database", "sync")
+    }
+
+    buildTypes {
+        release {
+            // Currently not obfuscating/minifying with ProGuard/R8.
+            isMinifyEnabled = false
+            proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
+        }
+    }
+
+    // Configure a flavor dimension based on if Admin is included in the Android database library.
+    // Note: common configuration defined in defaultConfig and buildTypes blocks above.
+    // https://developer.android.com/studio/build/build-variants#product-flavors
+    // Note: the name of this flavor should match the one of the depended on objectbox-android
+    // subproject, otherwise, additonal configuration is necessary to depend on the correct variant
+    // of it.
+    val dimensionAdmin = "admin"
+    flavorDimensions += listOf(dimensionAdmin)
+    productFlavors {
+        create(flavorAdminExcluded) {
+            dimension = dimensionAdmin
+        }
+        create(flavorAdminIncluded) {
+            dimension = dimensionAdmin
+        }
+    }
+
+    // Publish the release variants (variant = flavor combination + build type)
+    // https://developer.android.com/studio/publish-library/configure-pub-variants
+    publishing {
+        singleVariant(variantAdminExcludedRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+        singleVariant(variantAdminIncludedRelease) {
+            withJavadocJar()
+            withSourcesJar()
+        }
+    }
+
+    // Java 8 features support https://developer.android.com/studio/write/java8-support
+    // Note: this requires consuming projects to also enable this.
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_1_8
+        targetCompatibility = JavaVersion.VERSION_1_8
+    }
+
+    // For local unit tests enable use of Android framework with Robolectric
+    testOptions {
+        unitTests.isIncludeAndroidResources = true
+    }
+}
+
+val versionDatabaseLibraryJvm: String by rootProject.extra
+val versionDatabaseLibraryAndroidSync: String by rootProject.extra
+
+val adminExcludedImplementation by configurations.getting
+val adminIncludedImplementation by configurations.getting
+
+dependencies {
+    // Use "api" to add the Java library as a "compile" dependency in the POM as this library
+    // exposes APIs from it (MeshConfig). Regardless, it is expected that most consumers (or the
+    // Gradle plugin) add the Java library as a direct dependency.
+    api(project(":objectbox-java"))
+    // Use "implementation" to add the Nearby Connections library as a "runtime" dependency in the
+    // POM for consumers (it is required at runtime), but not expose any of its types via this
+    // library's API.
+    // Note: this library doesn't use Nearby APIs, but the Android database library it depends on
+    // does. Its artifact doesn't add the Nearby dependency as it's also used if not using mesh
+    // sync.
+    implementation(libs.play.services.nearby)
+
+    // Use "implementation" to add the Android database library as a "runtime" dependency in the
+    // POM for consumers as it is required at runtime, but doesn't expose any APIs.
+    // Note: as the artifacts produced by this project are also used by the ObjectBox Flutter
+    // package, don't add a dependency on objectbox-android to make it easier to release for Flutter
+    // only (and to avoid Flutter projects pulling in unused code and resources, such as for Admin).
+    adminExcludedImplementation("io.objectbox:objectbox-sync-android-db:$versionDatabaseLibraryAndroidSync")
+    adminIncludedImplementation("io.objectbox:objectbox-sync-android-db-admin:$versionDatabaseLibraryAndroidSync")
+
+    // Dependencies for unit tests running on the JVM (so not on an Android device/emulator)
+    testImplementation(libs.junit)
+    testImplementation(libs.androidx.test.core)
+    testImplementation(libs.robolectric)
+    testImplementation(libs.mockito.kotlin)
+    testImplementation("io.objectbox:objectbox-linux:${versionDatabaseLibraryJvm}")
+    testImplementation("io.objectbox:objectbox-macos:${versionDatabaseLibraryJvm}")
+    testImplementation("io.objectbox:objectbox-windows:${versionDatabaseLibraryJvm}")
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationMeshSyncAndroid = "objectboxMeshSyncAndroid"
+val publicationMeshSyncAndroidAdmin = "objectboxMeshSyncAndroidAdmin"
+publishing {
+    publications {
+        create<MavenPublication>(publicationMeshSyncAndroid) {
+            artifactId = "objectbox-meshsync-android"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminExcludedRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Mesh Sync for Android")
+            }
+        }
+        create<MavenPublication>(publicationMeshSyncAndroidAdmin) {
+            artifactId = "objectbox-meshsync-android-admin"
+
+            // Because the Android components are created during the evaluation phase,
+            // can only use them in the afterEvaluate() lifecycle method.
+            afterEvaluate {
+                from(components[variantAdminIncludedRelease])
+            }
+
+            pom {
+                name.set("ObjectBox Mesh Sync with Admin for Android")
+            }
+        }
+        // Additional common configuration for all Maven publications
+        withType<MavenPublication> {
+            pom {
+                description.set("Peer-to-peer mesh sync for ObjectBox Sync on Android using Google Nearby Connections")
+                packaging = "aar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationMeshSyncAndroid])
+    sign(publishing.publications[publicationMeshSyncAndroidAdmin])
+}
diff --git a/objectbox-meshsync-android/src/main/AndroidManifest.xml b/objectbox-meshsync-android/src/main/AndroidManifest.xml
new file mode 100644
index 00000000..9980b5ab
--- /dev/null
+++ b/objectbox-meshsync-android/src/main/AndroidManifest.xml
@@ -0,0 +1,44 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <!--
+      Permissions that may be needed by the Nearby Connections API; these are merged into the
+      manifest of apps using this library.
+
+      Note that not all permissions may be required. Depending on a device's Android SDK version and
+      your app's needs, only some of them may actually be necessary. For example, location
+      permissions are typically not required for Nearby Connections on recent Android releases.
+
+      To remove them as needed, use [merge rule markers](https://developer.android.com/build/manage-manifests)
+      in your app's manifest, for example:
+
+      <uses-permission
+          android:name="android.permission.ACCESS_COARSE_LOCATION"
+          tools:node="remove" />
+      <uses-permission
+          android:name="android.permission.ACCESS_FINE_LOCATION"
+          tools:node="remove" />
+
+      Note that maxSdkVersion restrictions should not be added to the Wi-Fi or Bluetooth
+      permissions; the Nearby API appears to require them on all SDK versions.
+
+      Also note that your app must request any dangerous (runtime) permissions at runtime when
+      needed.
+    -->
+    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
+    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.BLUETOOTH_ADVERTISE" />
+    <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
+    <uses-permission android:name="android.permission.BLUETOOTH_SCAN"
+        android:usesPermissionFlags="neverForLocation"
+        tools:targetApi="s" />
+    <uses-permission android:name="android.permission.NEARBY_WIFI_DEVICES"
+        android:usesPermissionFlags="neverForLocation"
+        tools:targetApi="tiramisu" />
+
+</manifest>
diff --git a/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/AndroidMeshSync.kt b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/AndroidMeshSync.kt
new file mode 100644
index 00000000..c041cbf5
--- /dev/null
+++ b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/AndroidMeshSync.kt
@@ -0,0 +1,88 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.objectbox.meshsync.android
+
+import android.content.Context
+import io.objectbox.annotation.apihint.Experimental
+import io.objectbox.internal.NativeLibraryUtils
+import io.objectbox.meshsync.android.AndroidMeshSync.createConfig
+import io.objectbox.meshsync.android.internal.NearbyMeshNetwork
+import io.objectbox.sync.InternalSyncAccess
+import io.objectbox.sync.MeshConfig
+import io.objectbox.sync.SyncBuilder
+import io.objectbox.sync.SyncClient
+
+/**
+ * Peer-to-peer mesh sync for Android using [Google Nearby Connections](https://developers.google.com/nearby/connections/overview).
+ * 
+ * Use [createConfig] to create a [MeshConfig] with the Android mesh
+ * network attached, then pass it to [SyncBuilder.mesh]:
+ * 
+ * ```
+ * val meshConfig: MeshConfig = AndroidMeshSync.createConfig(context, "example.myapp.mesh")
+ * 
+ * val syncClient: SyncClient = Sync.client(boxStore)
+ *     .url(SYNC_SERVER_URL)
+ *     .credentials(credentials)
+ *     .mesh(meshConfig)
+ *     .buildAndStart()
+ * ```
+ * 
+ * The mesh starts and stops together with the sync client; query the running mesh via
+ * [SyncClient.getMesh].
+ *
+ * Requirements:
+ * 
+ * * The app must use the Sync variant of the ObjectBox Android library (such as
+ *   `objectbox-sync-android`), which includes the native mesh sync code.
+ * * This library adds the permissions required by Nearby Connections to the app manifest. However,
+ *   the app must request the dangerous (runtime) permissions, like location and the newer
+ *   Bluetooth/Wi-Fi permissions, before starting the sync client. [MeshSyncPermissions] may help
+ *   with that.
+ * 
+ */
+@Experimental
+object AndroidMeshSync {
+
+    /**
+     * Creates a mesh sync configuration with an Android (Nearby Connections) mesh network
+     * attached.
+     *
+     * Configure optional settings on the returned [MeshConfig] (chainable setters), then pass
+     * it to [SyncBuilder.mesh]. See the [class documentation][AndroidMeshSync] for an example.
+     * 
+     * @param context Android context (the application context is used internally).
+     * @param meshId The mesh network identifier; nodes with different IDs ignore each other. Also
+     * used as the Nearby Connections service ID, so it should be unique to your application, for
+     * example, based on your application ID (like `example.myapp.mesh`).
+     * @return a [MeshConfig] to optionally configure further and pass to [SyncBuilder.mesh].
+     */
+    @JvmStatic
+    fun createConfig(context: Context, meshId: String): MeshConfig {
+        NativeLibraryUtils.checkHasFeature()
+
+        // Create the config first: it validates meshId, avoiding the creation of a native network
+        // for bad input.
+        val config = InternalSyncAccess.createMeshConfig(meshId)
+        // Create the Nearby network (Java + paired native object) and register it with the config.
+        // The native network is owned by the MeshSync once the sync client is created;
+        // see NearbyMeshNetwork.stop().
+        val network = NearbyMeshNetwork(context.applicationContext, meshId)
+        InternalSyncAccess.addNetworkInternalHandle(config, network.nativeHandle)
+        return config
+    }
+
+}
diff --git a/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt
new file mode 100644
index 00000000..390b4285
--- /dev/null
+++ b/objectbox-meshsync-android/src/main/java/io/objectbox/meshsync/android/MeshSyncPermissions.kt
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.meshsync.android
+
+import android.Manifest
+import android.app.Activity
+import android.content.pm.PackageManager
+import android.os.Build
+import io.objectbox.sync.MeshSync
+import io.objectbox.sync.SyncClient
+
+/**
+ * Helps to request Android runtime permissions for Mesh Sync.
+ *
+ * Usage:
+ *
+ * 1. Create an instance in the [Activity] that should be used to request permissions.
+ * 2. Override [Activity.onRequestPermissionsResult] and call [notifyMeshIfPermissionsGranted].
+ * 3. Call [requestIfMissing] to show permission requests to the user.
+ *
+ * ```
+ * class ExampleSetupActivity : Activity() {
+ *
+ *     private val meshSyncPermissions = MeshSyncPermissions(this)
+ *
+ *     override fun onRequestPermissionsResult(
+ *         requestCode: Int,
+ *         permissions: Array<out String>,
+ *         grantResults: IntArray
+ *     ) {
+ *         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
+ *         meshSyncPermissions.notifyMeshIfPermissionsGranted(
+ *             requestCode,
+ *             syncClient.mesh
+ *         )
+ *     }
+ *
+ *     fun onRequestPermissionsButtonClick() {
+ *         meshSyncPermissions.requestIfMissing()
+ *     }
+ * }
+ * ```
+ *
+ * If your app already [requests permissions](https://developer.android.com/training/permissions/requesting)
+ * for other purposes, it might want to use [missingRuntimePermissions] or [runtimePermissions]
+ * instead.
+ *
+ * Note that not all permissions this requests (as returned by [runtimePermissions] and declared in
+ * the included manifest) may be required. Depending on a device's Android SDK version and your
+ * app's needs, only some of them may actually be necessary. For example, location permissions are
+ * typically not required for Nearby Connections on recent Android releases.
+ */
+class MeshSyncPermissions(
+    private val activity: Activity
+) {
+
+    /**
+     * Requests any missing runtime permissions for Mesh Sync using the request code
+     * [PERMISSIONS_REQUEST_CODE].
+     *
+     * Note: before calling this, your code might want to check [Activity.shouldShowRequestPermissionRationale]
+     * if a rationale UI should be shown first. See how to
+     * [request permissions](https://developer.android.com/training/permissions/requesting).
+     */
+    fun requestIfMissing() {
+        val missingPermissions = missingRuntimePermissions()
+        if (missingPermissions.isEmpty()) {
+            return
+        }
+
+        // Before M, missingRuntimePermissions above would return an empty list
+        // and avoid calling this. But guard additionally for safety and to
+        // avoid a Lint error.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            activity.requestPermissions(missingPermissions.toTypedArray(), PERMISSIONS_REQUEST_CODE)
+        }
+    }
+
+    /**
+     * Returns `true` if the request code matches, all required permissions are granted and
+     * [MeshSync.retryNetworks] was called.
+     *
+     * Call this from [Activity.onRequestPermissionsResult] and pass the received [requestCode]
+     * and [SyncClient.getMesh] for [meshSync].
+     *
+     * Alternatively, your code can check itself if all [missingRuntimePermissions] are granted and
+     * then call [MeshSync.retryNetworks] (or create a [SyncClient]) itself.
+     */
+    fun notifyMeshIfPermissionsGranted(
+        requestCode: Int,
+        meshSync: MeshSync?
+    ): Boolean {
+        if (requestCode != PERMISSIONS_REQUEST_CODE) {
+            return false // Don't handle other requests
+        }
+        if (missingRuntimePermissions().size == runtimePermissions().size) {
+            return false // None of the requested runtime permissions granted
+        }
+
+        // Immediately retry if any permission was granted
+        meshSync?.retryNetworks()
+        return true
+    }
+
+    /**
+     * Returns the list of Mesh Sync runtime permissions that have not yet been granted.
+     */
+    fun missingRuntimePermissions(): List<String> {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+            return emptyList() // No runtime permissions before API 23
+        }
+
+        return runtimePermissions()
+            .filter { activity.checkSelfPermission(it) != PackageManager.PERMISSION_GRANTED }
+    }
+
+    companion object {
+        /** Request code used when calling [Activity.requestPermissions]. */
+        const val PERMISSIONS_REQUEST_CODE = 0x0B09
+
+        /**
+         * Returns dangerous (runtime) permissions that may be required for Mesh Sync on the current
+         * device, depending on its Android SDK version.
+         *
+         * See [MeshSyncPermissions] for additional notes on permissions.
+         */
+        fun runtimePermissions(): List<String> {
+            val permissions = mutableListOf(
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+                Manifest.permission.ACCESS_FINE_LOCATION
+            )
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                permissions += Manifest.permission.BLUETOOTH_ADVERTISE
+                permissions += Manifest.permission.BLUETOOTH_CONNECT
+                permissions += Manifest.permission.BLUETOOTH_SCAN
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                permissions += Manifest.permission.NEARBY_WIFI_DEVICES
+            }
+            return permissions
+        }
+    }
+}
diff --git a/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/AndroidMeshSyncTest.kt b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/AndroidMeshSyncTest.kt
new file mode 100644
index 00000000..c2a0cedc
--- /dev/null
+++ b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/AndroidMeshSyncTest.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.objectbox.meshsync.android
+
+import android.content.Context
+import androidx.test.core.app.ApplicationProvider
+import io.objectbox.exception.FeatureNotAvailableException
+import org.junit.Assert.assertThrows
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Tests run on the JVM using Robolectric against a JVM database library which does not include
+ * Sync.
+ *
+ * The internal objectbox repository has instrumented tests requiring the Sync feature and the
+ * Nearby Connections API run against the Android database library.
+ */
+@RunWith(RobolectricTestRunner::class)
+class AndroidMeshSyncTest {
+
+    @Test
+    fun createConfig_withoutSyncLibrary_throws() {
+        val context = ApplicationProvider.getApplicationContext<Context>()
+        val exception = assertThrows(FeatureNotAvailableException::class.java) {
+            AndroidMeshSync.createConfig(context, "test-mesh")
+        }
+        val message = exception.message!!
+        assertTrue(message, message.contains("does not include the Sync feature"))
+    }
+
+}
diff --git a/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/MeshSyncPermissionsTest.kt b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/MeshSyncPermissionsTest.kt
new file mode 100644
index 00000000..f11a3d40
--- /dev/null
+++ b/objectbox-meshsync-android/src/test/java/io/objectbox/meshsync/android/MeshSyncPermissionsTest.kt
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.meshsync.android
+
+import android.Manifest
+import android.app.Activity
+import io.objectbox.sync.MeshSync
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito.*
+import org.robolectric.Robolectric
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+
+@RunWith(RobolectricTestRunner::class)
+class MeshSyncPermissionsTest {
+
+    private lateinit var activity: Activity
+    private lateinit var meshSyncPermissions: MeshSyncPermissions
+
+    @Before
+    fun setUp() {
+        activity = Robolectric.buildActivity(Activity::class.java).create().get()
+        meshSyncPermissions = MeshSyncPermissions(activity)
+    }
+
+    private fun grantAllPermissions() {
+        shadowOf(RuntimeEnvironment.getApplication())
+            .grantPermissions(*MeshSyncPermissions.runtimePermissions().toTypedArray())
+    }
+
+    @Test
+    fun requestIfMissing_allGranted_permissionsNotRequested() {
+        grantAllPermissions()
+
+        meshSyncPermissions.requestIfMissing()
+
+        assertNull(
+            "requestPermissions should not have been called when all permissions are granted",
+            shadowOf(activity).lastRequestedPermission
+        )
+    }
+
+    @Test
+    fun requestIfMissing_missing_requestsPermissions() {
+        meshSyncPermissions.requestIfMissing()
+
+        val lastRequest = shadowOf(activity).lastRequestedPermission
+        assertNotNull("requestPermissions should have been called on the Activity", lastRequest)
+        assertEquals(
+            "Request code should match PERMISSIONS_REQUEST_CODE",
+            MeshSyncPermissions.PERMISSIONS_REQUEST_CODE,
+            lastRequest!!.requestCode
+        )
+    }
+
+    private fun assertNotifyMeshIfPermissionsGranted(
+        requestCode: Int = MeshSyncPermissions.PERMISSIONS_REQUEST_CODE,
+        expectedHandled: Boolean,
+        expectRetryNetworksCalled: Boolean
+    ) {
+        val meshSync = mock(MeshSync::class.java)
+        val handled = meshSyncPermissions.notifyMeshIfPermissionsGranted(requestCode, meshSync)
+        assertEquals(expectedHandled, handled)
+        if (expectRetryNetworksCalled) verify(meshSync).retryNetworks()
+        else verify(meshSync, never()).retryNetworks()
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_allGranted_retryNetworksCalled() {
+        grantAllPermissions()
+
+        assertNotifyMeshIfPermissionsGranted(
+            expectedHandled = true,
+            expectRetryNetworksCalled = true
+        )
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_oneGranted_retryNetworksCalled() {
+        shadowOf(RuntimeEnvironment.getApplication())
+            .grantPermissions(Manifest.permission.NEARBY_WIFI_DEVICES)
+
+        assertNotifyMeshIfPermissionsGranted(
+            expectedHandled = true,
+            expectRetryNetworksCalled = true
+        )
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_noneGranted_returnsFalse() {
+        assertNotifyMeshIfPermissionsGranted(
+            expectedHandled = false,
+            expectRetryNetworksCalled = false
+        )
+    }
+
+    @Test
+    fun notifyMeshIfPermissionsGranted_wrongCode_returnsFalse() {
+        // Not required with the current implementation, but things might change
+        grantAllPermissions()
+
+        assertNotifyMeshIfPermissionsGranted(
+            requestCode = 0x1234,
+            expectedHandled = false,
+            expectRetryNetworksCalled = false
+        )
+    }
+
+}
diff --git a/objectbox-rxjava/build.gradle b/objectbox-rxjava/build.gradle
deleted file mode 100644
index 11b7e6a9..00000000
--- a/objectbox-rxjava/build.gradle
+++ /dev/null
@@ -1,48 +0,0 @@
-apply plugin: 'java-library'
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-dependencies {
-    api project(':objectbox-java')
-    api 'io.reactivex.rxjava2:rxjava:2.2.18'
-
-    testImplementation "junit:junit:$junit_version"
-    testImplementation "org.mockito:mockito-core:$mockito_version"
-}
-
-task javadocJar(type: Jar, dependsOn: javadoc) {
-    archiveClassifier.set('javadoc')
-    from 'build/docs/javadoc'
-}
-
-task sourcesJar(type: Jar) {
-    archiveClassifier.set('sources')
-    from sourceSets.main.allSource
-}
-
-artifacts {
-    // java plugin adds jar.
-    archives javadocJar
-    archives sourcesJar
-}
-
-uploadArchives {
-    repositories {
-        mavenDeployer {
-            // Basic definitions are defined in root project
-            pom.project {
-                name 'ObjectBox RxJava API'
-                description 'RxJava extension for ObjectBox'
-
-                licenses {
-                    license {
-                        name 'The Apache Software License, Version 2.0'
-                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-                        distribution 'repo'
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/objectbox-rxjava/build.gradle.kts b/objectbox-rxjava/build.gradle.kts
new file mode 100644
index 00000000..8348ef3e
--- /dev/null
+++ b/objectbox-rxjava/build.gradle.kts
@@ -0,0 +1,53 @@
+plugins {
+    id("java-library")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+dependencies {
+    api(project(":objectbox-java"))
+    api(libs.rxjava2)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.mockito)
+}
+
+val javadocJar by tasks.registering(Jar::class) {
+    dependsOn(tasks.javadoc)
+    archiveClassifier.set("javadoc")
+    from("build/docs/javadoc")
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxRxjava = "objectboxRxjava"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxRxjava) {
+            artifactId = "objectbox-rxjava"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            artifact(javadocJar)
+
+            pom {
+                name.set("ObjectBox RxJava API")
+                description.set("RxJava extension for ObjectBox")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxRxjava])
+}
diff --git a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
index f6f585bb..b700de6b 100644
--- a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
+++ b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxBoxStore.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
index 13b838a0..25cdd099 100644
--- a/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
+++ b/objectbox-rxjava/src/main/java/io/objectbox/rx/RxQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java b/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
index 6237c75a..88817347 100644
--- a/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
+++ b/objectbox-rxjava/src/test/java/io/objectbox/query/FakeQueryPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java b/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
index 3e86e7c7..df0432f3 100644
--- a/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
+++ b/objectbox-rxjava/src/test/java/io/objectbox/query/MockQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -35,7 +35,7 @@ public MockQuery(boolean hasOrder) {
         // when(box.getStore()).thenReturn(boxStore);
          query = mock(Query.class);
         fakeQueryPublisher = new FakeQueryPublisher();
-        SubscriptionBuilder subscriptionBuilder = new SubscriptionBuilder(fakeQueryPublisher, null, null);
+        SubscriptionBuilder subscriptionBuilder = new SubscriptionBuilder(fakeQueryPublisher, null);
         when(query.subscribe()).thenReturn(subscriptionBuilder);
     }
 
diff --git a/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java b/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
index 7389effd..71aaadd9 100644
--- a/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
+++ b/objectbox-rxjava/src/test/java/io/objectbox/rx/QueryObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/build.gradle b/objectbox-rxjava3/build.gradle
deleted file mode 100644
index 97869de9..00000000
--- a/objectbox-rxjava3/build.gradle
+++ /dev/null
@@ -1,79 +0,0 @@
-buildscript {
-    ext.javadocDir = "$buildDir/docs/javadoc"
-}
-
-apply plugin: 'java-library'
-apply plugin: 'kotlin'
-apply plugin: 'org.jetbrains.dokka'
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-// Produce Java 8 byte code, would default to Java 6.
-tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).configureEach {
-    kotlinOptions {
-        jvmTarget = "1.8"
-    }
-}
-
-dokka {
-    outputFormat = 'html'
-    outputDirectory = javadocDir
-
-    // Fix "Can't find node by signature": have to manually point to dependencies.
-    // https://github.com/Kotlin/dokka/wiki/faq#dokka-complains-about-cant-find-node-by-signature-
-    configuration{
-        externalDocumentationLink {
-            // Point to web javadoc for objectbox-java packages.
-            url = new URL("https://objectbox.io/docfiles/java/current/")
-            // Note: Using JDK 9+ package-list is now called element-list.
-            packageListUrl = new URL(url, "element-list")
-        }
-    }
-}
-
-dependencies {
-    api project(':objectbox-java')
-    api 'io.reactivex.rxjava3:rxjava:3.0.1'
-    compileOnly "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-    testImplementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-    testImplementation "junit:junit:$junit_version"
-    testImplementation "org.mockito:mockito-core:$mockito_version"
-}
-
-task javadocJar(type: Jar, dependsOn: dokka) {
-    archiveClassifier.set('javadoc')
-    from "$javadocDir"
-}
-
-task sourcesJar(type: Jar) {
-    archiveClassifier.set('sources')
-    from sourceSets.main.allSource
-}
-
-artifacts {
-    // java plugin adds jar.
-    archives javadocJar
-    archives sourcesJar
-}
-
-uploadArchives {
-    repositories {
-        mavenDeployer {
-            // Basic definitions are defined in root project
-            pom.project {
-                name 'ObjectBox RxJava 3 API'
-                description 'RxJava 3 extensions for ObjectBox'
-
-                licenses {
-                    license {
-                        name 'The Apache Software License, Version 2.0'
-                        url 'http://www.apache.org/licenses/LICENSE-2.0.txt'
-                        distribution 'repo'
-                    }
-                }
-            }
-        }
-    }
-}
diff --git a/objectbox-rxjava3/build.gradle.kts b/objectbox-rxjava3/build.gradle.kts
new file mode 100644
index 00000000..1c3cd605
--- /dev/null
+++ b/objectbox-rxjava3/build.gradle.kts
@@ -0,0 +1,60 @@
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("java-library")
+    alias(libs.plugins.kotlin.jvm)
+    id("objectbox.dokka-conventions")
+    id("objectbox.publishing-conventions")
+}
+
+// Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+// https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+tasks.withType<JavaCompile> {
+    options.release.set(8)
+}
+
+kotlin {
+    compilerOptions {
+        // Produce Java 8 byte code, would default to Java 6
+        jvmTarget.set(JvmTarget.JVM_1_8)
+    }
+}
+
+dependencies {
+    api(project(":objectbox-java"))
+    api(libs.rxjava3)
+
+    testImplementation(libs.junit)
+    testImplementation(libs.mockito)
+}
+
+val sourcesJar by tasks.registering(Jar::class) {
+    group = "build"
+    archiveClassifier.set("sources")
+    from(sourceSets.main.get().allSource)
+}
+
+// Note: common settings applied by objectbox.publishing-conventions plugin
+val publicationObjectboxRxjava3 = "objectboxRxjava3"
+publishing {
+    publications {
+        create<MavenPublication>(publicationObjectboxRxjava3) {
+            artifactId = "objectbox-rxjava3"
+
+            from(components["java"])
+            artifact(sourcesJar)
+            // Note: the javadocJar task is created by the objectbox.dokka-conventions plugin
+            artifact(tasks.named("javadocJar"))
+
+            pom {
+                name.set("ObjectBox RxJava 3 API")
+                description.set("RxJava 3 extensions for ObjectBox")
+                packaging = "jar"
+            }
+        }
+    }
+}
+
+signing {
+    sign(publishing.publications[publicationObjectboxRxjava3])
+}
diff --git a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt
index 6960f96e..b0a5f21e 100644
--- a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt
+++ b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/Query.kt
@@ -9,7 +9,7 @@ import io.reactivex.rxjava3.core.Single
 /**
  * Shortcut for [`RxQuery.flowableOneByOne(query, strategy)`][RxQuery.flowableOneByOne].
  */
-fun <T> Query<T>.flowableOneByOne(strategy: BackpressureStrategy = BackpressureStrategy.BUFFER): Flowable<T> {
+fun <T : Any> Query<T>.flowableOneByOne(strategy: BackpressureStrategy = BackpressureStrategy.BUFFER): Flowable<T> {
     return RxQuery.flowableOneByOne(this, strategy)
 }
 
diff --git a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java
index 79f8f1d0..e627bc6a 100644
--- a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java
+++ b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxBoxStore.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java
index feadfdd1..fea5d46c 100644
--- a/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java
+++ b/objectbox-rxjava3/src/main/java/io/objectbox/rx3/RxQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java b/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java
index a550b4a1..a74dcd21 100644
--- a/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java
+++ b/objectbox-rxjava3/src/test/java/io/objectbox/query/FakeQueryPublisher.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java b/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java
index 8b28d0ab..d627b492 100644
--- a/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java
+++ b/objectbox-rxjava3/src/test/java/io/objectbox/query/MockQuery.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -40,9 +40,7 @@ public MockQuery(boolean hasOrder) {
         //noinspection unchecked It's a unit test, casting is fine.
         query = (Query<T>) mock(Query.class);
         fakeQueryPublisher = new FakeQueryPublisher<>();
-        //noinspection ConstantConditions ExecutorService only used for transforms.
-        SubscriptionBuilder<List<T>> subscriptionBuilder = new SubscriptionBuilder<>(
-                fakeQueryPublisher, null, null);
+        SubscriptionBuilder<List<T>> subscriptionBuilder = new SubscriptionBuilder<>(fakeQueryPublisher, null);
         when(query.subscribe()).thenReturn(subscriptionBuilder);
     }
 
diff --git a/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java b/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java
index bdf70d98..a0602a65 100644
--- a/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java
+++ b/objectbox-rxjava3/src/test/java/io/objectbox/rx3/QueryObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/scripts/set-version.sh b/scripts/set-version.sh
new file mode 100755
index 00000000..196b1ad0
--- /dev/null
+++ b/scripts/set-version.sh
@@ -0,0 +1,175 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# This script has a regular and a `--release` mode.
+#
+# In regular mode this script will:
+# - update `versionNumber` in `/build.gradle.kts`
+# - in `CHANGELOG.md`, if it doesn't exist, add a next release heading
+# - on confirmation, commit the changes
+# - suggest a git command to push the changes
+#
+# In release mode:
+# - ask to confirm `versionNumber` in `/build.gradle.kts`
+# - in `BoxStore.java` update `JNI_VERSION` to match `VERSION`
+# - in `README.md` update version numbers in known locations
+# - in `CHANGELOG.md` change the next version header to the new version and date
+# - on confirmation, commit the changes, create a release tag
+# - suggest git commands to push the changes
+
+# Parse optional --release flag
+releaseFlag=false
+for arg in "$@"; do
+    case "$arg" in
+        --release) releaseFlag=true ;;
+    esac
+done
+
+# macOS includes BSD versions of sed and grep, which have different options and syntax than the
+# expected GNU versions. So require users of this script to install gsed and ggrep.
+if [[ "$OSTYPE" == "darwin"* ]]; then
+  if ! command -v gsed &>/dev/null; then
+    echo "Error: gsed is required but not installed. Install it, for example using 'brew install gnu-sed'."
+    exit 1
+  fi
+  if ! command -v ggrep &>/dev/null; then
+    echo "Error: ggrep is required but not installed. Install it, for example using 'brew install grep'."
+    exit 1
+  fi
+  sed="gsed"
+  grep="ggrep"
+else
+  sed="sed"
+  grep="grep"
+fi
+
+scriptDir="$(dirname "$0")"
+
+propVersionNumber="versionNumber"
+buildScriptFile="../build.gradle.kts"
+buildScriptPath="$scriptDir/$buildScriptFile"
+
+boxStorePath="$scriptDir/../objectbox-java/src/main/java/io/objectbox/BoxStore.java"
+readmePath="$scriptDir/../README.md"
+changelogPath="$scriptDir/../CHANGELOG.md"
+nextReleaseHeading="## Next release"
+
+# Extract the value of `versionNumber` in build.gradle.kts and store it in the versionCurrent variable
+buildScriptPath="$(dirname "$0")/$buildScriptFile"
+# Regex matches 'versionNumber = "..."', \K to only capture the version string inside the quotes
+versionCurrent=$($grep --only-matching --perl-regexp "$propVersionNumber"' = "\K[^"]+' "$buildScriptPath" || true)
+if [[ -z "$versionCurrent" ]]; then
+    echo "Error: could not find '$propVersionNumber' in '$buildScriptFile'"
+    exit 1
+fi
+
+echo ""
+echo "Maven artifacts version ($propVersionNumber in $buildScriptFile)"
+echo "Current:    $versionCurrent"
+
+if $releaseFlag; then
+    # Release: Confirm the current version
+    read -r -p "Press enter to confirm the current version, or enter a custom one: " versionInput
+    if [[ -n "$versionInput" ]]; then
+        versionNew="$versionInput"
+    else
+        versionNew="$versionCurrent"
+    fi
+else
+    # Suggest a next version
+    # Increment the last number in the version string (like 5.4.2 -> 5.4.3, 5.4.2-preview1 -> 5.4.2-preview2)
+    # Regex: captures the trailing digits and replaces them with a value increased by 1
+    [[ "$versionCurrent" =~ ^(.*[^0-9])([0-9]+)$ ]] || { echo "Error: $propVersionNumber '$versionCurrent' does not end with a number"; exit 1; }
+    versionSuggested="${BASH_REMATCH[1]}$(( BASH_REMATCH[2] + 1 ))"
+    echo "Suggested:  $versionSuggested"
+    read -r -p "Press enter to use the suggested version, or enter a custom one: " versionInput
+    if [[ -n "$versionInput" ]]; then
+        versionNew="$versionInput"
+    else
+        versionNew="$versionSuggested"
+    fi
+fi
+echo "Version will be $versionNew"
+
+# Change the value of `versionNumber` in build.gradle.kts to the value of versionNew
+$sed --in-place "s/$propVersionNumber = \"$versionCurrent\"/$propVersionNumber = \"$versionNew\"/" "$buildScriptPath"
+
+if $releaseFlag; then
+    # In BoxStore.java set JNI_VERSION to the value of VERSION (not using versionNew!) and print the used value
+    # Regex matches 'String VERSION = "...", \K to only capture the version string inside the quotes
+    versionJni=$($grep --only-matching --perl-regexp 'String VERSION = "\K[^"]+' "$boxStorePath" || true)
+    if [[ -z "$versionJni" ]]; then
+        echo "Error: could not find VERSION in BoxStore.java"
+        exit 1
+    fi
+    echo "Release: setting BoxStore.JNI_VERSION to $versionJni"
+    $sed --in-place "s/String JNI_VERSION = \".*\"/String JNI_VERSION = \"$versionJni\"/" "$boxStorePath"
+
+    # Change version strings in README.md to versionNew
+    echo "Release: updating README.md version strings"
+    $sed --in-place "s/objectbox = \".*\"/objectbox = \"$versionNew\"/g" "$readmePath"
+    $sed --in-place "s/id(\"io.objectbox\") version \".*\"/id(\"io.objectbox\") version \"$versionNew\"/g" "$readmePath"
+    $sed --in-place "s/val objectboxVersion by extra(\".*\")/val objectboxVersion by extra(\"$versionNew\")/g" "$readmePath"
+    $sed --in-place "s/ext.objectboxVersion = \".*\"/ext.objectboxVersion = \"$versionNew\"/g" "$readmePath"
+
+    # Change header "Next release" in CHANGELOG.md to "versionNew - YYYY-MM-DD"
+    echo "Release: updating CHANGELOG.md heading"
+    today=$(date +"%Y-%m-%d")
+    if $grep --quiet "^$nextReleaseHeading" "$changelogPath"; then
+        $sed --in-place "s/^$nextReleaseHeading/## $versionNew - $today/" "$changelogPath"
+    else
+        echo "⚠️ '$nextReleaseHeading' heading not found in CHANGELOG.md, check it contains changes for this release!"
+    fi
+else
+    # In CHANGELOG.md, if the first secondary heading is not "## Next release", add it
+    firstHeading=$($grep --max-count=1 "^## " "$changelogPath" || true)
+    if [[ "$firstHeading" != "$nextReleaseHeading" ]]; then
+        echo "Adding '$nextReleaseHeading' to CHANGELOG.md"
+        $sed --in-place "0,/^## /{s/^## /$nextReleaseHeading\n\n## /}" "$changelogPath"
+    fi
+fi
+
+# After confirmation commit any changes and for a release create a tag
+# Example for a release:
+# git commit --all --message="Prepare release 5.4.0"
+# git tag V5.4.0
+# For a regular run:
+# git commit --all --message="Publishing: increase version 5.4.0 -> 5.4.1"
+if $releaseFlag; then
+    commitMessage="Prepare release $versionNew"
+else
+    commitMessage="Publishing: increase version $versionCurrent -> $versionNew"
+fi
+tagRelease="V$versionNew"
+
+echo ""
+echo "About to run git commands:"
+echo "  git commit --all --message=\"$commitMessage\""
+if $releaseFlag; then
+    echo "  git tag $tagRelease"
+fi
+
+read -r -p "Reviewed changes? Proceed? [y/N] " confirm
+if [[ "$confirm" != "y" && "$confirm" != "Y" ]]; then
+    echo "Aborted."
+    exit 1
+fi
+
+git commit --all --message="$commitMessage"
+if $releaseFlag; then
+    git tag "$tagRelease"
+fi
+
+# Print suggested git commands to push the changes
+# Note: add `--push-option=ci.skip` to avoid running CI
+# Examples:
+# git push origin publish --push-option=ci.skip
+# git push origin V5.4.0 --push-option=ci.skip
+
+currentBranch=$(git rev-parse --abbrev-ref HEAD)
+echo ""
+echo "Suggested commands to push these changes:"
+echo "  git push origin $currentBranch --push-option=ci.skip"
+if $releaseFlag; then
+    echo "  git push origin $tagRelease --push-option=ci.skip"
+fi
diff --git a/scripts/test-with-asan.sh b/scripts/test-with-asan.sh
new file mode 100755
index 00000000..b52ed90e
--- /dev/null
+++ b/scripts/test-with-asan.sh
@@ -0,0 +1,89 @@
+#!/usr/bin/env bash
+set -e
+
+# Enables running Gradle tasks with JNI libraries built with AddressSanitizer (ASan).
+#
+# Note: currently only objectbox feature branches build JNI libraries with ASan. If this is used
+# with "regularly" built JNI libraries this will run without error, but also NOT detect any issues.
+#
+# Arguments are passed directly to Gradle. If no arguments are specified runs the 'test' task.
+#
+# This script supports the following environment variables:
+#
+# - ASAN_LIB_SO: path to ASan library, if not set tries to detect path
+# - ASAN_SYMBOLIZER_PATH: path to llvm-symbolizer, if not set tries to detect path
+# - ASAN_OPTIONS: ASan options, if not set configures to not detect leaks
+#
+# The ASan detection is known to work with the buildenv-core:2024-07-11 image or Ubuntu 24.04 with a clang setup.
+
+# AddressSanitizer shared library (clang or gcc setup)
+# https://github.com/google/sanitizers/wiki/AddressSanitizer
+if [ -z "$ASAN_LIB_SO" ]; then  # If not supplied (e.g. by CI script), try to locate the lib:
+    ASAN_ARCH=$(uname -m) # x86_64 or aarch64
+    echo "No ASAN_LIB_SO defined, trying to locate dynamically..."
+    # Known to work on Ubuntu 24.04: Find in the typical llvm directory (using `tail` for latest version; `head` would be oldest")
+    ASAN_LIB_SO_CLANG_LATEST=$(find /usr/lib/llvm-*/ -name libclang_rt.asan-${ASAN_ARCH}.so | tail -1)
+    # Known to work with clang 16 on Rocky Linux 8.10 (path is like /usr/local/lib/clang/16/lib/x86_64-unknown-linux-gnu/libclang_rt.asan.so)
+    ASAN_LIB_SO_CLANG=$(clang -print-file-name=libclang_rt.asan.so || true)
+    # Approach via https://stackoverflow.com/a/54386573/551269, but use libasan.so.8 instead of libasan.so
+    # to not find the linker script, but the actual library (and to avoid parsing it out of the linker script).
+    ASAN_LIB_SO_GCC=$(gcc -print-file-name=libasan.so.8 || true)
+    echo "clang latest asan lib: ${ASAN_LIB_SO_CLANG_LATEST}"
+    echo "       clang asan lib: ${ASAN_LIB_SO_CLANG}"
+    echo "         gcc asan lib: ${ASAN_LIB_SO_GCC}"
+    # prefer clang version in case clang llvm-symbolizer is used (see below)
+    if [ -f "${ASAN_LIB_SO_CLANG_LATEST}" ]; then
+        export ASAN_LIB_SO="${ASAN_LIB_SO_CLANG_LATEST}"
+    elif [ -f "${ASAN_LIB_SO_CLANG}" ]; then
+        export ASAN_LIB_SO="${ASAN_LIB_SO_CLANG}"
+    elif [ -f "${ASAN_LIB_SO_GCC}" ]; then
+        export ASAN_LIB_SO="${ASAN_LIB_SO_GCC}"
+    else
+        echo "No asan lib found; please specify via ASAN_LIB_SO"
+        exit 1
+    fi
+fi
+
+# Set up llvm-symbolizer to symbolize a stack trace (clang setup only)
+# https://github.com/google/sanitizers/wiki/AddressSanitizerCallStack
+# Rocky Linux 8 (buildenv-core)
+if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
+    echo "ASAN_SYMBOLIZER_PATH not set, trying to find it in /usr/local/bin/..."
+    export ASAN_SYMBOLIZER_PATH="$(find /usr/local/bin/ -name llvm-symbolizer | tail -1 )"
+fi
+# Ubuntu 22.04
+if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
+    echo "ASAN_SYMBOLIZER_PATH not set, trying to find it in /usr/lib/llvm-*/..."
+    export ASAN_SYMBOLIZER_PATH="$(find /usr/lib/llvm-*/ -name llvm-symbolizer | tail -1)"
+fi
+
+# Turn off leak detection by default
+# https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
+if [ -z "$ASAN_OPTIONS" ]; then
+    echo "ASAN_OPTIONS not set, setting default values"
+    export ASAN_OPTIONS="detect_leaks=0"
+fi
+
+echo ""
+echo "ℹ️ test-with-asan.sh final values:"
+echo "ASAN_LIB_SO: $ASAN_LIB_SO"
+echo "ASAN_SYMBOLIZER_PATH: $ASAN_SYMBOLIZER_PATH"
+echo "ASAN_OPTIONS: $ASAN_OPTIONS"
+echo "ASAN_LIB_SO resolves to:"
+ls -l $ASAN_LIB_SO
+echo "ASAN_SYMBOLIZER_PATH resolves to:"
+if [ -z "$ASAN_SYMBOLIZER_PATH" ]; then
+    echo "WARNING: ASAN_SYMBOLIZER_PATH not set, stack traces will not be symbolized"
+else
+    ls -l $ASAN_SYMBOLIZER_PATH
+fi
+
+if [[ $# -eq 0 ]] ; then
+    args=test
+else
+    args=$@
+fi
+
+echo ""
+echo "➡️ Running Gradle with arguments \"$args\" in directory $(pwd)..."
+LD_PRELOAD=${ASAN_LIB_SO} ./gradlew ${args}
diff --git a/scripts/update-flatbuffers.sh b/scripts/update-flatbuffers.sh
new file mode 100644
index 00000000..eb790bab
--- /dev/null
+++ b/scripts/update-flatbuffers.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Expects FlatBuffers source files in the `../flatbuffers` directory,
+# the Java library in `objectbox-java`, e.g. run this from the root of this repo.
+
+script_dir=$(dirname "$(readlink -f "$0")")
+cd "${script_dir}/.." # move to project root dir or exit on failure
+echo "Running in directory: $(pwd)"
+
+src="../flatbuffers/java/src/main/java/com/google/flatbuffers"
+dest="objectbox-java/src/main/java/io/objectbox/flatbuffers"
+
+echo "Copying flatbuffers Java sources"
+rm -f ${dest}/*.java
+cp -v ${src}/*.java ${dest}/
+
+echo "Updating import statements of Java sources"
+find "${dest}" -type f -name "*.java" \
+  -exec echo "Processing {}" \; \
+  -exec sed -i "s| com.google.flatbuffers| io.objectbox.flatbuffers|g" {} \;
diff --git a/settings.gradle b/settings.gradle
deleted file mode 100644
index 24da1d92..00000000
--- a/settings.gradle
+++ /dev/null
@@ -1,8 +0,0 @@
-include ':objectbox-java-api'
-include ':objectbox-java'
-include ':objectbox-kotlin'
-include ':objectbox-rxjava'
-include ':objectbox-rxjava3'
-
-include ':tests:objectbox-java-test'
-include ':tests:test-proguard'
diff --git a/settings.gradle.kts b/settings.gradle.kts
new file mode 100644
index 00000000..0de155c9
--- /dev/null
+++ b/settings.gradle.kts
@@ -0,0 +1,71 @@
+pluginManagement {
+    includeBuild("build-logic")
+    repositories {
+        // Google: for Android plugin
+        google {
+            content {
+                includeGroupByRegex("com\\.android.*")
+                includeGroupByRegex("com\\.google.*")
+                includeGroupByRegex("androidx.*")
+            }
+        }
+        mavenCentral() // For dokka plugin
+        gradlePluginPortal()
+    }
+}
+
+// While this is an incubating API, it is the recommended way of declaring repositories:
+// https://docs.gradle.org/current/userguide/best_practices_dependencies.html#set_up_repositories_in_settings
+dependencyResolutionManagement {
+    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
+    repositories {
+        google() // For Android dependencies
+        mavenCentral()
+
+        // Internal ObjectBox repo to get snapshot versions of dependencies
+        val gitlabUrl = providers.gradleProperty("gitlabUrl")
+        val gitlabPrivateTokenName = providers.gradleProperty("gitlabPrivateTokenName")
+        val gitlabPrivateToken = providers.gradleProperty("gitlabPrivateToken")
+        if (gitlabUrl.isPresent) {
+            maven {
+                name = "GitLab"
+                url = uri("${gitlabUrl.get()}/api/v4/groups/objectbox/-/packages/maven")
+                credentials(HttpHeaderCredentials::class) {
+                    name = gitlabPrivateTokenName.orNull ?: "Private-Token"
+                    value = gitlabPrivateToken.get()
+                }
+                authentication {
+                    create<HttpHeaderAuthentication>("header")
+                }
+                println("Dependencies: added GitLab repository at $url")
+            }
+        } else {
+            println("Dependencies: GitLab repository NOT added, see settings file for required project properties")
+        }
+    }
+}
+
+plugins {
+    // Supports resolving toolchains for JVM projects
+    // https://docs.gradle.org/9.5.1/userguide/toolchains.html#sub:download_repositories
+    // https://github.com/gradle/foojay-toolchains/blob/main/CHANGELOG.md
+    id("org.gradle.toolchains.foojay-resolver-convention") version ("1.0.0")
+}
+
+rootProject.name = "objectbox-java"
+
+include(":objectbox-java-api")
+include(":objectbox-java")
+include(":objectbox-kotlin")
+include(":objectbox-rxjava")
+include(":objectbox-rxjava3")
+
+// Allow to conditionally exclude projects that require the Android SDK to build
+val excludeAndroid: String? by settings
+if (excludeAndroid == null) {
+    include(":objectbox-android")
+    include(":objectbox-meshsync-android")
+}
+
+include(":tests:objectbox-java-test")
+include(":tests:test-proguard")
diff --git a/tests/README.md b/tests/README.md
new file mode 100644
index 00000000..4e2b96b1
--- /dev/null
+++ b/tests/README.md
@@ -0,0 +1,22 @@
+# ObjectBox Java API tests
+
+Note: As the Gradle plugin and therefore code generation is not available, these tests use copies (partially customized
+for testing) of generated ObjectBox helper classes like `MyObjectBox`, meta and cursor classes.
+
+The following test projects exist:
+
+- [objectbox-java-test](objectbox-java-test): basic tests of Java APIs using JVM libraries with Sync (client only)
+  feature
+- [test-proguard](test-proguard): despite its name, only a very basic create, read and delete test using the regular JVM
+  library (so without Sync)
+
+Extended tests exist in the internal Java integration test repository.
+
+## Naming convention for tests
+
+All new test methods should be named like: `{subject}_{operation}_{expectation}`
+
+For ex. to test a date query condition: `date_lessAndGreater_works`
+
+Note: due to historic reasons existing test methods (written for JUnit 3) may be named differently (with a `test`
+prefix).
diff --git a/tests/objectbox-java-test/build.gradle b/tests/objectbox-java-test/build.gradle
deleted file mode 100644
index 0fe15497..00000000
--- a/tests/objectbox-java-test/build.gradle
+++ /dev/null
@@ -1,50 +0,0 @@
-apply plugin: 'java-library'
-
-uploadArchives.enabled = false
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-repositories {
-    // Native lib might be deployed only in internal repo
-    if (project.hasProperty('internalObjectBoxRepo')) {
-        println "internalObjectBoxRepo=$internalObjectBoxRepo added to repositories."
-        maven {
-            credentials {
-                username internalObjectBoxRepoUser
-                password internalObjectBoxRepoPassword
-            }
-            url internalObjectBoxRepo
-        }
-    } else {
-        println "WARNING: Property internalObjectBoxRepo not set."
-    }
-}
-
-dependencies {
-    implementation project(':objectbox-java')
-    implementation 'org.greenrobot:essentials:3.0.0-RC1'
-
-    // Check flag to use locally compiled version to avoid dependency cycles
-    if (!project.hasProperty('noObjectBoxTestDepencies') || !noObjectBoxTestDepencies) {
-        println "Using $ob_native_dep"
-        implementation ob_native_dep
-    } else {
-        println "Did NOT add native dependency"
-    }
-
-    testImplementation "junit:junit:$junit_version"
-}
-
-test {
-    // This is pretty useless now because it floods console with warnings about internal Java classes
-    // However we might check from time to time, also with Java 9.
-    // jvmArgs '-Xcheck:jni'
-
-    testLogging {
-        showStandardStreams = true
-        exceptionFormat = 'full'
-        displayGranularity = 2
-        events 'started', 'passed'
-    }
-}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/build.gradle.kts b/tests/objectbox-java-test/build.gradle.kts
new file mode 100644
index 00000000..c00657f4
--- /dev/null
+++ b/tests/objectbox-java-test/build.gradle.kts
@@ -0,0 +1,91 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+import org.gradle.api.tasks.testing.logging.TestLogEvent
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
+
+plugins {
+    id("java-library")
+    id("kotlin")
+}
+
+tasks.withType<JavaCompile> {
+    // Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+    // https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+    options.release.set(8)
+}
+
+kotlin {
+    compilerOptions {
+        // Produce Java 8 byte code, would default to Java 6
+        jvmTarget.set(JvmTarget.JVM_1_8)
+    }
+}
+
+val versionDatabaseLibraryJvmSync: String by rootProject.extra
+
+dependencies {
+    implementation(project(":objectbox-java"))
+    implementation(libs.kotlin.coroutines.core)
+    implementation(project(":objectbox-kotlin"))
+    implementation(libs.essentials)
+    implementation("io.objectbox:objectbox-sync-linux:$versionDatabaseLibraryJvmSync")
+    implementation("io.objectbox:objectbox-sync-macos:$versionDatabaseLibraryJvmSync")
+    implementation("io.objectbox:objectbox-sync-windows:$versionDatabaseLibraryJvmSync")
+
+    testImplementation(libs.junit)
+    // To test Coroutines
+    testImplementation(libs.kotlin.coroutines.test)
+    // To test Kotlin Flow
+    testImplementation(libs.turbine)
+}
+
+val testInMemory by tasks.registering(Test::class) {
+    group = "verification"
+    description = "Run unit tests with in-memory database"
+    systemProperty("obx.inMemory", true)
+}
+
+// Run in-memory tests as part of regular check run
+tasks.check {
+    dependsOn(testInMemory)
+}
+
+tasks.withType<Test> {
+    if (System.getenv("TEST_WITH_JAVA_X86") == "true") {
+        // To run tests with 32-bit ObjectBox
+        // Note: 32-bit JDK is only available on Windows
+        val javaExecutablePath = System.getenv("JAVA_HOME_X86") + "\\bin\\java.exe"
+        println("$name: will run tests with $javaExecutablePath")
+        executable = javaExecutablePath
+    } else if (System.getenv("TEST_JDK") != null) {
+        // To run tests on a different JDK, uses Gradle toolchains API (https://docs.gradle.org/current/userguide/toolchains.html)
+        val sdkVersionInt = System.getenv("TEST_JDK").toInt()
+        println("$name: will run tests with JDK $sdkVersionInt")
+        javaLauncher.set(javaToolchains.launcherFor {
+            languageVersion.set(JavaLanguageVersion.of(sdkVersionInt))
+        })
+    }
+
+    // This is pretty useless now because it floods console with warnings about internal Java classes
+    // However we might check from time to time, also with Java 9.
+    // jvmArgs "-Xcheck:jni"
+
+    filter {
+        // Note: Tree API currently incubating on Linux only.
+        if (!System.getProperty("os.name").lowercase().contains("linux")) {
+            excludeTestsMatching("io.objectbox.tree.*")
+        }
+    }
+
+    testLogging {
+        exceptionFormat = TestExceptionFormat.FULL
+        displayGranularity = 2
+        // Note: this overwrites showStandardStreams = true, so set it by
+        // adding the standard out/error events.
+        events = setOf(
+            TestLogEvent.STARTED,
+            TestLogEvent.PASSED,
+            TestLogEvent.STANDARD_OUT,
+            TestLogEvent.STANDARD_ERROR
+        )
+    }
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java
index e1766f24..17553df3 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,7 +16,25 @@
 
 package io.objectbox;
 
-/** In "real" entity would be annotated with @Entity. */
+import java.util.Arrays;
+import java.util.Date;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.Id;
+import io.objectbox.annotation.Unsigned;
+
+/**
+ * The annotations in this class have no effect as the Gradle plugin is not configured in this project. They are
+ * informational to help maintain the test code that builds a model for this entity (see AbstractObjectBoxTest).
+ * <p>
+ * To test annotations and correct code generation, add a test in the Gradle plugin project. To test related features
+ * with a database at runtime, add a test in the internal integration test project.
+ */
+@Entity
 public class TestEntity {
 
     public static final String STRING_VALUE_THROW_IN_CONSTRUCTOR =
@@ -25,7 +43,7 @@ public class TestEntity {
     public static final String EXCEPTION_IN_CONSTRUCTOR_MESSAGE =
             "Hello, this is an exception from TestEntity constructor";
 
-    /** In "real" entity would be annotated with @Id. */
+    @Id
     private long id;
     private boolean simpleBoolean;
     private byte simpleByte;
@@ -34,16 +52,28 @@ public class TestEntity {
     private long simpleLong;
     private float simpleFloat;
     private double simpleDouble;
-    /** Not-null value. */
     private String simpleString;
     /** Not-null value. */
     private byte[] simpleByteArray;
-    /** In "real" entity would be annotated with @Unsigned. */
+    /** Not-null value. */
+    private String[] simpleStringArray;
+    private List<String> simpleStringList;
+    @Unsigned
     private short simpleShortU;
-    /** In "real" entity would be annotated with @Unsigned. */
+    @Unsigned
     private int simpleIntU;
-    /** In "real" entity would be annotated with @Unsigned. */
+    @Unsigned
     private long simpleLongU;
+    private Map<String, Object> stringObjectMap;
+    private Object flexProperty;
+    private boolean[] booleanArray;
+    private short[] shortArray;
+    private char[] charArray;
+    private int[] intArray;
+    private long[] longArray;
+    private float[] floatArray;
+    private double[] doubleArray;
+    private Date date;
 
     transient boolean noArgsConstructorCalled;
 
@@ -55,7 +85,32 @@ public TestEntity(long id) {
         this.id = id;
     }
 
-    public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleShort, int simpleInt, long simpleLong, float simpleFloat, double simpleDouble, String simpleString, byte[] simpleByteArray, short simpleShortU, int simpleIntU, long simpleLongU) {
+    public TestEntity(long id,
+                      boolean simpleBoolean,
+                      byte simpleByte,
+                      short simpleShort,
+                      int simpleInt,
+                      long simpleLong,
+                      float simpleFloat,
+                      double simpleDouble,
+                      String simpleString,
+                      byte[] simpleByteArray,
+                      String[] simpleStringArray,
+                      List<String> simpleStringList,
+                      short simpleShortU,
+                      int simpleIntU,
+                      long simpleLongU,
+                      Map<String, Object> stringObjectMap,
+                      Object flexProperty,
+                      boolean[] booleanArray,
+                      short[] shortArray,
+                      char[] charArray,
+                      int[] intArray,
+                      long[] longArray,
+                      float[] floatArray,
+                      double[] doubleArray,
+                      Date date
+    ) {
         this.id = id;
         this.simpleBoolean = simpleBoolean;
         this.simpleByte = simpleByte;
@@ -66,9 +121,21 @@ public TestEntity(long id, boolean simpleBoolean, byte simpleByte, short simpleS
         this.simpleDouble = simpleDouble;
         this.simpleString = simpleString;
         this.simpleByteArray = simpleByteArray;
+        this.simpleStringArray = simpleStringArray;
+        this.simpleStringList = simpleStringList;
         this.simpleShortU = simpleShortU;
         this.simpleIntU = simpleIntU;
         this.simpleLongU = simpleLongU;
+        this.stringObjectMap = stringObjectMap;
+        this.flexProperty = flexProperty;
+        this.booleanArray = booleanArray;
+        this.shortArray = shortArray;
+        this.charArray = charArray;
+        this.intArray = intArray;
+        this.longArray = longArray;
+        this.floatArray = floatArray;
+        this.doubleArray = doubleArray;
+        this.date = date;
         if (STRING_VALUE_THROW_IN_CONSTRUCTOR.equals(simpleString)) {
             throw new RuntimeException(EXCEPTION_IN_CONSTRUCTOR_MESSAGE);
         }
@@ -138,13 +205,12 @@ public void setSimpleDouble(double simpleDouble) {
         this.simpleDouble = simpleDouble;
     }
 
-    /** Not-null value. */
+    @Nullable
     public String getSimpleString() {
         return simpleString;
     }
 
-    /** Not-null value; ensure this value is available before it is saved to the database. */
-    public void setSimpleString(String simpleString) {
+    public void setSimpleString(@Nullable String simpleString) {
         this.simpleString = simpleString;
     }
 
@@ -158,30 +224,165 @@ public void setSimpleByteArray(byte[] simpleByteArray) {
         this.simpleByteArray = simpleByteArray;
     }
 
+    /** Not-null value. */
+    public String[] getSimpleStringArray() {
+        return simpleStringArray;
+    }
+
+    /** Not-null value; ensure this value is available before it is saved to the database. */
+    public void setSimpleStringArray(String[] simpleStringArray) {
+        this.simpleStringArray = simpleStringArray;
+    }
+
+    public List<String> getSimpleStringList() {
+        return simpleStringList;
+    }
+
+    public void setSimpleStringList(List<String> simpleStringList) {
+        this.simpleStringList = simpleStringList;
+    }
+
     public short getSimpleShortU() {
         return simpleShortU;
     }
 
-    public TestEntity setSimpleShortU(short simpleShortU) {
+    public void setSimpleShortU(short simpleShortU) {
         this.simpleShortU = simpleShortU;
-        return this;
     }
 
     public int getSimpleIntU() {
         return simpleIntU;
     }
 
-    public TestEntity setSimpleIntU(int simpleIntU) {
+    public void setSimpleIntU(int simpleIntU) {
         this.simpleIntU = simpleIntU;
-        return this;
     }
 
     public long getSimpleLongU() {
         return simpleLongU;
     }
 
-    public TestEntity setSimpleLongU(long simpleLongU) {
+    public void setSimpleLongU(long simpleLongU) {
         this.simpleLongU = simpleLongU;
-        return this;
+    }
+
+    public Map<String, Object> getStringObjectMap() {
+        return stringObjectMap;
+    }
+
+    public void setStringObjectMap(Map<String, Object> stringObjectMap) {
+        this.stringObjectMap = stringObjectMap;
+    }
+
+    @Nullable
+    public Object getFlexProperty() {
+        return flexProperty;
+    }
+
+    public void setFlexProperty(@Nullable Object flexProperty) {
+        this.flexProperty = flexProperty;
+    }
+
+    @Nullable
+    public boolean[] getBooleanArray() {
+        return booleanArray;
+    }
+
+    public void setBooleanArray(@Nullable boolean[] booleanArray) {
+        this.booleanArray = booleanArray;
+    }
+
+    @Nullable
+    public short[] getShortArray() {
+        return shortArray;
+    }
+
+    public void setShortArray(@Nullable short[] shortArray) {
+        this.shortArray = shortArray;
+    }
+
+    @Nullable
+    public char[] getCharArray() {
+        return charArray;
+    }
+
+    public void setCharArray(@Nullable char[] charArray) {
+        this.charArray = charArray;
+    }
+
+    @Nullable
+    public int[] getIntArray() {
+        return intArray;
+    }
+
+    public void setIntArray(@Nullable int[] intArray) {
+        this.intArray = intArray;
+    }
+
+    @Nullable
+    public long[] getLongArray() {
+        return longArray;
+    }
+
+    public void setLongArray(@Nullable long[] longArray) {
+        this.longArray = longArray;
+    }
+
+    @Nullable
+    public float[] getFloatArray() {
+        return floatArray;
+    }
+
+    public void setFloatArray(@Nullable float[] floatArray) {
+        this.floatArray = floatArray;
+    }
+
+    @Nullable
+    public double[] getDoubleArray() {
+        return doubleArray;
+    }
+
+    public void setDoubleArray(@Nullable double[] doubleArray) {
+        this.doubleArray = doubleArray;
+    }
+
+    public Date getDate() {
+        return date;
+    }
+
+    public void setDate(Date date) {
+        this.date = date;
+    }
+
+    @Override
+    public String toString() {
+        return "TestEntity{" +
+                "id=" + id +
+                ", simpleBoolean=" + simpleBoolean +
+                ", simpleByte=" + simpleByte +
+                ", simpleShort=" + simpleShort +
+                ", simpleInt=" + simpleInt +
+                ", simpleLong=" + simpleLong +
+                ", simpleFloat=" + simpleFloat +
+                ", simpleDouble=" + simpleDouble +
+                ", simpleString='" + simpleString + '\'' +
+                ", simpleByteArray=" + Arrays.toString(simpleByteArray) +
+                ", simpleStringArray=" + Arrays.toString(simpleStringArray) +
+                ", simpleStringList=" + simpleStringList +
+                ", simpleShortU=" + simpleShortU +
+                ", simpleIntU=" + simpleIntU +
+                ", simpleLongU=" + simpleLongU +
+                ", stringObjectMap=" + stringObjectMap +
+                ", flexProperty=" + flexProperty +
+                ", booleanArray=" + Arrays.toString(booleanArray) +
+                ", shortArray=" + Arrays.toString(shortArray) +
+                ", charArray=" + Arrays.toString(charArray) +
+                ", intArray=" + Arrays.toString(intArray) +
+                ", longArray=" + Arrays.toString(longArray) +
+                ", floatArray=" + Arrays.toString(floatArray) +
+                ", doubleArray=" + Arrays.toString(doubleArray) +
+                ", date=" + date +
+                ", noArgsConstructorCalled=" + noArgsConstructorCalled +
+                '}';
     }
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java
index 55752103..6727a063 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,10 +16,16 @@
 
 package io.objectbox;
 
+import java.util.Map;
+
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.converter.FlexObjectConverter;
+import io.objectbox.converter.StringFlexMapConverter;
 import io.objectbox.internal.CursorFactory;
 
-// NOTE: Copied from a plugin project (& removed some unused Properties).
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// TestEntity. But make sure to keep the INT_NULL_HACK to make it work with tests here.
+
 // THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
 
 /**
@@ -41,6 +47,8 @@ public Cursor<TestEntity> createCursor(io.objectbox.Transaction tx, long cursorH
 
     private static final TestEntity_.TestEntityIdGetter ID_GETTER = TestEntity_.__ID_GETTER;
 
+    private final StringFlexMapConverter stringObjectMapConverter = new StringFlexMapConverter();
+    private final FlexObjectConverter flexPropertyConverter = new FlexObjectConverter();
 
     private final static int __ID_simpleBoolean = TestEntity_.simpleBoolean.id;
     private final static int __ID_simpleByte = TestEntity_.simpleByte.id;
@@ -51,16 +59,28 @@ public Cursor<TestEntity> createCursor(io.objectbox.Transaction tx, long cursorH
     private final static int __ID_simpleDouble = TestEntity_.simpleDouble.id;
     private final static int __ID_simpleString = TestEntity_.simpleString.id;
     private final static int __ID_simpleByteArray = TestEntity_.simpleByteArray.id;
+    private final static int __ID_simpleStringArray = TestEntity_.simpleStringArray.id;
+    private final static int __ID_simpleStringList = TestEntity_.simpleStringList.id;
     private final static int __ID_simpleShortU = TestEntity_.simpleShortU.id;
     private final static int __ID_simpleIntU = TestEntity_.simpleIntU.id;
     private final static int __ID_simpleLongU = TestEntity_.simpleLongU.id;
+    private final static int __ID_stringObjectMap = TestEntity_.stringObjectMap.id;
+    private final static int __ID_flexProperty = TestEntity_.flexProperty.id;
+    private final static int __ID_booleanArray = TestEntity_.booleanArray.id;
+    private final static int __ID_shortArray = TestEntity_.shortArray.id;
+    private final static int __ID_charArray = TestEntity_.charArray.id;
+    private final static int __ID_intArray = TestEntity_.intArray.id;
+    private final static int __ID_longArray = TestEntity_.longArray.id;
+    private final static int __ID_floatArray = TestEntity_.floatArray.id;
+    private final static int __ID_doubleArray = TestEntity_.doubleArray.id;
+    private final static int __ID_date = TestEntity_.date.id;
 
     public TestEntityCursor(io.objectbox.Transaction tx, long cursor, BoxStore boxStore) {
         super(tx, cursor, TestEntity_.__INSTANCE, boxStore);
     }
 
     @Override
-    public final long getId(TestEntity entity) {
+    public long getId(TestEntity entity) {
         return ID_GETTER.getId(entity);
     }
 
@@ -69,24 +89,92 @@ public final long getId(TestEntity entity) {
      *
      * @return The ID of the object within its box.
      */
+    @SuppressWarnings({"rawtypes", "unchecked"})
     @Override
-    public final long put(TestEntity entity) {
+    public long put(TestEntity entity) {
+        boolean[] booleanArray = entity.getBooleanArray();
+        int __id17 = booleanArray != null ? __ID_booleanArray : 0;
+
+        collectBooleanArray(cursor, 0, PUT_FLAG_FIRST,
+                __id17, booleanArray);
+
+        short[] shortArray = entity.getShortArray();
+        int __id18 = shortArray != null ? __ID_shortArray : 0;
+
+        collectShortArray(cursor, 0, 0,
+                __id18, shortArray);
+
+        char[] charArray = entity.getCharArray();
+        int __id19 = charArray != null ? __ID_charArray : 0;
+
+        collectCharArray(cursor, 0, 0,
+                __id19, charArray);
+
+        int[] intArray = entity.getIntArray();
+        int __id20 = intArray != null ? __ID_intArray : 0;
+
+        collectIntArray(cursor, 0, 0,
+                __id20, intArray);
+
+        long[] longArray = entity.getLongArray();
+        int __id21 = longArray != null ? __ID_longArray : 0;
+
+        collectLongArray(cursor, 0, 0,
+                __id21, longArray);
+
+        float[] floatArray = entity.getFloatArray();
+        int __id22 = floatArray != null ? __ID_floatArray : 0;
+
+        collectFloatArray(cursor, 0, 0,
+                __id22, floatArray);
+
+        double[] doubleArray = entity.getDoubleArray();
+        int __id23 = doubleArray != null ? __ID_doubleArray : 0;
+
+        collectDoubleArray(cursor, 0, 0,
+                __id23, doubleArray);
+
+        String[] simpleStringArray = entity.getSimpleStringArray();
+        int __id10 = simpleStringArray != null ? __ID_simpleStringArray : 0;
+
+        collectStringArray(cursor, 0, 0,
+                __id10, simpleStringArray);
+
+        java.util.List<String> simpleStringList = entity.getSimpleStringList();
+        int __id11 = simpleStringList != null ? __ID_simpleStringList : 0;
+
+        collectStringList(cursor, 0, 0,
+                __id11, simpleStringList);
+
         String simpleString = entity.getSimpleString();
         int __id8 = simpleString != null ? __ID_simpleString : 0;
         byte[] simpleByteArray = entity.getSimpleByteArray();
         int __id9 = simpleByteArray != null ? __ID_simpleByteArray : 0;
+        Map stringObjectMap = entity.getStringObjectMap();
+        int __id15 = stringObjectMap != null ? __ID_stringObjectMap : 0;
+        Object flexProperty = entity.getFlexProperty();
+        int __id16 = flexProperty != null ? __ID_flexProperty : 0;
 
-        collect313311(cursor, 0, PUT_FLAG_FIRST,
+        collect430000(cursor, 0, 0,
                 __id8, simpleString, 0, null,
-                0, null, __id9, simpleByteArray,
+                0, null, 0, null,
+                __id9, simpleByteArray, __id15, __id15 != 0 ? stringObjectMapConverter.convertToDatabaseValue(stringObjectMap) : null,
+                __id16, __id16 != 0 ? flexPropertyConverter.convertToDatabaseValue(flexProperty) : null);
+
+        java.util.Date date = entity.getDate();
+        int __id24 = date != null ? __ID_date : 0;
+
+        collect313311(cursor, 0, 0,
+                0, null, 0, null,
+                0, null, 0, null,
                 __ID_simpleLong, entity.getSimpleLong(), __ID_simpleLongU, entity.getSimpleLongU(),
-                INT_NULL_HACK ? 0 : __ID_simpleInt, entity.getSimpleInt(), __ID_simpleIntU, entity.getSimpleIntU(),
-                __ID_simpleShort, entity.getSimpleShort(), __ID_simpleShortU, entity.getSimpleShortU(),
+                __id24, __id24 != 0 ? date.getTime() : 0, INT_NULL_HACK ? 0 : __ID_simpleInt, entity.getSimpleInt(),
+                __ID_simpleIntU, entity.getSimpleIntU(), __ID_simpleShort, entity.getSimpleShort(),
                 __ID_simpleFloat, entity.getSimpleFloat(), __ID_simpleDouble, entity.getSimpleDouble());
 
         long __assignedId = collect004000(cursor, entity.getId(), PUT_FLAG_COMPLETE,
-                __ID_simpleByte, entity.getSimpleByte(), __ID_simpleBoolean, entity.getSimpleBoolean() ? 1 : 0,
-                0, 0, 0, 0);
+                __ID_simpleShortU, entity.getSimpleShortU(), __ID_simpleByte, entity.getSimpleByte(),
+                __ID_simpleBoolean, entity.getSimpleBoolean() ? 1 : 0, 0, 0);
 
         entity.setId(__assignedId);
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java
index 051d2a2f..9d37b5b7 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java
index 01e67968..6bfd89b7 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimalCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java
index 95ec8b27..c74afa7a 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntityMinimal_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java
index 1bc39153..a6e5097e 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/TestEntity_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,12 +16,18 @@
 
 package io.objectbox;
 
+import java.util.Map;
+
 import io.objectbox.TestEntityCursor.Factory;
 import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.converter.FlexObjectConverter;
+import io.objectbox.converter.StringFlexMapConverter;
 import io.objectbox.internal.CursorFactory;
 import io.objectbox.internal.IdGetter;
 
-// NOTE: Copied from a plugin project (& removed some unused Properties).
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// TestEntity.
+
 // THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
 
 /**
@@ -77,14 +82,50 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
     public final static io.objectbox.Property<TestEntity> simpleByteArray =
             new io.objectbox.Property<>(__INSTANCE, 9, 10, byte[].class, "simpleByteArray");
 
+    public final static io.objectbox.Property<TestEntity> simpleStringArray =
+            new io.objectbox.Property<>(__INSTANCE, 10, 11, String[].class, "simpleStringArray");
+
+    public final static io.objectbox.Property<TestEntity> simpleStringList =
+            new io.objectbox.Property<>(__INSTANCE, 11, 15, java.util.List.class, "simpleStringList");
+
     public final static io.objectbox.Property<TestEntity> simpleShortU =
-            new io.objectbox.Property<>(__INSTANCE, 10, 11, short.class, "simpleShortU");
+            new io.objectbox.Property<>(__INSTANCE, 12, 12, short.class, "simpleShortU");
 
     public final static io.objectbox.Property<TestEntity> simpleIntU =
-            new io.objectbox.Property<>(__INSTANCE, 11, 12, int.class, "simpleIntU");
+            new io.objectbox.Property<>(__INSTANCE, 13, 13, int.class, "simpleIntU");
 
     public final static io.objectbox.Property<TestEntity> simpleLongU =
-            new io.objectbox.Property<>(__INSTANCE, 12, 13, long.class, "simpleLongU");
+            new io.objectbox.Property<>(__INSTANCE, 14, 14, long.class, "simpleLongU");
+
+    public final static io.objectbox.Property<TestEntity> stringObjectMap =
+            new io.objectbox.Property<>(__INSTANCE, 15, 16, byte[].class, "stringObjectMap", false, "stringObjectMap", StringFlexMapConverter.class, Map.class);
+
+    public final static io.objectbox.Property<TestEntity> flexProperty =
+            new io.objectbox.Property<>(__INSTANCE, 16, 17, byte[].class, "flexProperty", false, "flexProperty", FlexObjectConverter.class, Object.class);
+
+    public final static io.objectbox.Property<TestEntity> booleanArray =
+            new io.objectbox.Property<>(__INSTANCE, 17, 26, boolean[].class, "booleanArray");
+
+    public final static io.objectbox.Property<TestEntity> shortArray =
+            new io.objectbox.Property<>(__INSTANCE, 18, 18, short[].class, "shortArray");
+
+    public final static io.objectbox.Property<TestEntity> charArray =
+            new io.objectbox.Property<>(__INSTANCE, 19, 19, char[].class, "charArray");
+
+    public final static io.objectbox.Property<TestEntity> intArray =
+            new io.objectbox.Property<>(__INSTANCE, 20, 20, int[].class, "intArray");
+
+    public final static io.objectbox.Property<TestEntity> longArray =
+            new io.objectbox.Property<>(__INSTANCE, 21, 21, long[].class, "longArray");
+
+    public final static io.objectbox.Property<TestEntity> floatArray =
+            new io.objectbox.Property<>(__INSTANCE, 22, 22, float[].class, "floatArray");
+
+    public final static io.objectbox.Property<TestEntity> doubleArray =
+            new io.objectbox.Property<>(__INSTANCE, 23, 23, double[].class, "doubleArray");
+
+    public final static io.objectbox.Property<TestEntity> date =
+            new io.objectbox.Property<>(__INSTANCE, 24, 24, java.util.Date.class, "date");
 
     @SuppressWarnings("unchecked")
     public final static io.objectbox.Property<TestEntity>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
@@ -98,9 +139,21 @@ public final class TestEntity_ implements EntityInfo<TestEntity> {
             simpleDouble,
             simpleString,
             simpleByteArray,
+            simpleStringArray,
+            simpleStringList,
             simpleShortU,
             simpleIntU,
-            simpleLongU
+            simpleLongU,
+            stringObjectMap,
+            flexProperty,
+            booleanArray,
+            shortArray,
+            charArray,
+            intArray,
+            longArray,
+            floatArray,
+            doubleArray,
+            date
     };
 
     public final static io.objectbox.Property<TestEntity> __ID_PROPERTY = id;
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java
index 1bb9c503..290ec1dc 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java
index d55c72c4..20f9cc79 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndexCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,7 +19,6 @@
 
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
-import io.objectbox.EntityInfo;
 import io.objectbox.Transaction;
 
 // THIS CODE was originally GENERATED BY ObjectBox.
@@ -29,9 +28,6 @@
  */
 public final class EntityLongIndexCursor extends Cursor<EntityLongIndex> {
 
-    private static EntityInfo PROPERTIES = new EntityLongIndex_();
-
-
     // Property IDs get verified in Cursor base class
     private final static int __ID_indexedLong = EntityLongIndex_.indexedLong.id;
     private final static int __ID_float1 = EntityLongIndex_.float1.id;
@@ -41,11 +37,11 @@ public final class EntityLongIndexCursor extends Cursor<EntityLongIndex> {
     private final static int __ID_float5 = EntityLongIndex_.float5.id;
 
     public EntityLongIndexCursor(Transaction tx, long cursor, BoxStore boxStore) {
-        super(tx, cursor, PROPERTIES, boxStore);
+        super(tx, cursor, EntityLongIndex_.__INSTANCE, boxStore);
     }
 
     @Override
-    public final long getId(EntityLongIndex entity) {
+    public long getId(EntityLongIndex entity) {
         return entity.getId();
     }
 
@@ -55,7 +51,7 @@ public final long getId(EntityLongIndex entity) {
      * @return The ID of the object within its box.
      */
     @Override
-    public final long put(EntityLongIndex entity) {
+    public long put(EntityLongIndex entity) {
         Float float1 = entity.float1;
         int __id2 = float1 != null ? __ID_float1 : 0;
         Float float2 = entity.float2;
@@ -84,9 +80,4 @@ public final long put(EntityLongIndex entity) {
         return __assignedId;
     }
 
-    // TODO do we need this? @Override
-    protected final boolean isEntityUpdateable() {
-        return true;
-    }
-
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java
index dfa2ac1a..6b1d6341 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/EntityLongIndex_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java
index 5fb23c47..29d21138 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/index/model/MyObjectBox.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -43,7 +43,7 @@ public static BoxStoreBuilder builder() {
     private static byte[] getModel() {
         ModelBuilder modelBuilder = new ModelBuilder();
         modelBuilder.lastEntityId(8, 602677774947261949L);
-        modelBuilder.lastIndexId(4, 4720210528670921467L);
+        modelBuilder.lastIndexId(4, 3512264863194799103L);
 
         EntityBuilder entityBuilder;
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java
index 8f6dc36b..7523f146 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,13 +20,19 @@
 import java.util.List;
 
 import io.objectbox.BoxStore;
+import io.objectbox.annotation.Backlink;
 import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.Id;
 import io.objectbox.annotation.Index;
-import io.objectbox.annotation.apihint.Internal;
 
 /**
- * Entity mapped to table "CUSTOMER".
+ * Customer entity to test relations together with {@link Order}.
+ * <p>
+ * The annotations in this class have no effect as the Gradle plugin is not configured in this project. However, test
+ * code builds a model like if the annotations were processed.
+ * <p>
+ * There is a matching test in the internal integration test project where this is tested and model builder code can be
+ * "stolen" from.
  */
 @Entity
 public class Customer implements Serializable {
@@ -37,12 +43,16 @@ public class Customer implements Serializable {
     @Index
     private String name;
 
+    // Note: in a typical project the relation fields are initialized by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
+
+    @Backlink(to = "customer")
     List<Order> orders = new ToMany<>(this, Customer_.orders);
 
     ToMany<Order> ordersStandalone = new ToMany<>(this, Customer_.ordersStandalone);
 
-    /** Used to resolve relations */
-    @Internal
+    // Note: in a typical project the BoxStore field is added by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
     transient BoxStore __boxStore;
 
     public Customer() {
@@ -76,4 +86,5 @@ public List<Order> getOrders() {
     public ToMany<Order> getOrdersStandalone() {
         return ordersStandalone;
     }
+
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java
index ed721f38..3b546c56 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/CustomerCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,15 +17,13 @@
 package io.objectbox.relation;
 
 
-import java.util.List;
-
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
-import io.objectbox.EntityInfo;
 import io.objectbox.Transaction;
 import io.objectbox.internal.CursorFactory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Cursor for DB entity "Customer".
@@ -38,18 +36,15 @@ public Cursor<Customer> createCursor(Transaction tx, long cursorHandle, BoxStore
         }
     }
 
-    private static EntityInfo PROPERTIES = new Customer_();
-
-
     // Property IDs get verified in Cursor base class
     private final static int __ID_name = Customer_.name.id;
 
     public CustomerCursor(Transaction tx, long cursor, BoxStore boxStore) {
-        super(tx, cursor, PROPERTIES, boxStore);
+        super(tx, cursor, Customer_.__INSTANCE, boxStore);
     }
 
     @Override
-    public final long getId(Customer entity) {
+    public long getId(Customer entity) {
         return entity.getId();
     }
 
@@ -59,7 +54,7 @@ public final long getId(Customer entity) {
      * @return The ID of the object within its box.
      */
     @Override
-    public final long put(Customer entity) {
+    public long put(Customer entity) {
         String name = entity.getName();
         int __id1 = name != null ? __ID_name : 0;
 
@@ -74,21 +69,10 @@ public final long put(Customer entity) {
         entity.setId(__assignedId);
         entity.__boxStore = boxStoreForEntities;
 
-        checkApplyToManyToDb(entity.orders, Order.class);
+        checkApplyToManyToDb(entity.getOrders(), Order.class);
         checkApplyToManyToDb(entity.getOrdersStandalone(), Order.class);
 
         return __assignedId;
     }
 
-    // TODO @Override
-    protected final void attachEntity(Customer entity) {
-        // TODO super.attachEntity(entity);
-        entity.__boxStore = boxStoreForEntities;
-    }
-
-    // TODO do we need this? @Override
-    protected final boolean isEntityUpdateable() {
-        return true;
-    }
-
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java
index bcb28f40..2889c134 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Customer_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -28,7 +27,8 @@
 import io.objectbox.internal.ToOneGetter;
 import io.objectbox.relation.CustomerCursor.Factory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Properties for entity "Customer". Can be used for QueryBuilder and for referencing DB names.
@@ -108,24 +108,24 @@ public long getId(Customer object) {
         }
     }
 
-    static final RelationInfo<Customer, Order> orders =
-            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer>() {
+    public static final RelationInfo<Customer, Order> orders =
+            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer, Order>() {
                 @Override
                 public List<Order> getToMany(Customer customer) {
                     return customer.getOrders();
                 }
-            }, Order_.customerId, new ToOneGetter<Order>() {
+            }, Order_.customerId, new ToOneGetter<Order, Customer>() {
                 @Override
                 public ToOne<Customer> getToOne(Order order) {
-                    return order.customer__toOne;
+                    return order.getCustomer();
                 }
             });
 
-    static final RelationInfo<Customer, Order> ordersStandalone =
-            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer>() {
+    public static final RelationInfo<Customer, Order> ordersStandalone =
+            new RelationInfo<>(Customer_.__INSTANCE, Order_.__INSTANCE, new ToManyGetter<Customer, Order>() {
                 @Override
                 public List<Order> getToMany(Customer customer) {
-                    return customer.getOrders();
+                    return customer.getOrdersStandalone();
                 }
             }, 1);
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java
index 5e6b8271..3e2ee529 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/MyObjectBox.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -23,8 +23,9 @@
 import io.objectbox.model.PropertyFlags;
 import io.objectbox.model.PropertyType;
 
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
 /**
  * Starting point for working with your ObjectBox. All boxes are set up for your objects here.
  * <p>
@@ -46,15 +47,15 @@ private static byte[] getModel() {
         modelBuilder.lastIndexId(2, 8919874872236271392L);
         modelBuilder.lastRelationId(1, 8943758920347589435L);
 
-        EntityBuilder entityBuilder;
-
-        entityBuilder = modelBuilder.entity("Customer");
+        EntityBuilder entityBuilder = modelBuilder.entity("Customer");
         entityBuilder.id(1, 8247662514375611729L).lastPropertyId(2, 7412962174183812632L);
         entityBuilder.property("_id", PropertyType.Long).id(1, 1888039726372206411L)
                 .flags(PropertyFlags.ID | PropertyFlags.ID_SELF_ASSIGNABLE);
         entityBuilder.property("name", PropertyType.String).id(2, 7412962174183812632L)
                 .flags(PropertyFlags.INDEXED).indexId(1, 5782921847050580892L);
+
         entityBuilder.relation("ordersStandalone", 1, 8943758920347589435L, 3, 6367118380491771428L);
+
         entityBuilder.entityDone();
 
 
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java
index 419d3cfc..6c0fc967 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,16 +18,19 @@
 
 import java.io.Serializable;
 
-import javax.annotation.Nullable;
-
 import io.objectbox.BoxStore;
 import io.objectbox.annotation.Entity;
 import io.objectbox.annotation.Id;
 import io.objectbox.annotation.NameInDb;
-import io.objectbox.annotation.apihint.Internal;
 
 /**
- * Entity mapped to table "ORDERS".
+ * Order entity to test relations together with {@link Customer}.
+ * <p>
+ * The annotations in this class have no effect as the Gradle plugin is not configured in this project. However, test
+ * code builds a model like if the annotations were processed.
+ * <p>
+ * There is a matching test in the internal integration test project where this is tested and model builder code can be
+ * "stolen" from.
  */
 @Entity
 @NameInDb("ORDERS")
@@ -39,15 +42,15 @@ public class Order implements Serializable {
     long customerId;
     String text;
 
-    private Customer customer;
+    // Note: in a typical project the relation fields are initialized by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
+    @SuppressWarnings("FieldMayBeFinal")
+    private ToOne<Customer> customer = new ToOne<>(this, Order_.customer);
 
-    /** @Depreacted Used to resolve relations */
-    @Internal
+    // Note: in a typical project the BoxStore field is added by the ObjectBox byte code transformer
+    // https://docs.objectbox.io/relations#initialization-magic
     transient BoxStore __boxStore;
 
-    @Internal
-    transient ToOne<Customer> customer__toOne = new ToOne<>(this, Order_.customer);
-
     public Order() {
     }
 
@@ -94,20 +97,8 @@ public void setText(String text) {
         this.text = text;
     }
 
-    public Customer peekCustomer() {
+    public ToOne<Customer> getCustomer() {
         return customer;
     }
 
-    /** To-one relationship, resolved on first access. */
-    public Customer getCustomer() {
-        customer = customer__toOne.getTarget(this.customerId);
-        return customer;
-    }
-
-    /** Set the to-one relation including its ID property. */
-    public void setCustomer(@Nullable Customer customer) {
-        customer__toOne.setTarget(customer);
-        this.customer = customer;
-    }
-
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java
index 66181710..999c664d 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/OrderCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,11 +18,11 @@
 
 import io.objectbox.BoxStore;
 import io.objectbox.Cursor;
-import io.objectbox.EntityInfo;
 import io.objectbox.Transaction;
 import io.objectbox.internal.CursorFactory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Cursor for DB entity "ORDERS".
@@ -48,7 +48,7 @@ public OrderCursor(Transaction tx, long cursor, BoxStore boxStore) {
     }
 
     @Override
-    public final long getId(Order entity) {
+    public long getId(Order entity) {
         return ID_GETTER.getId(entity);
     }
 
@@ -58,11 +58,12 @@ public final long getId(Order entity) {
      * @return The ID of the object within its box.
      */
     @Override
-    public final long put(Order entity) {
-        if(entity.customer__toOne.internalRequiresPutTarget()) {
+    public long put(Order entity) {
+        ToOne<Customer> customer = entity.getCustomer();
+        if(customer != null && customer.internalRequiresPutTarget()) {
             Cursor<Customer> targetCursor = getRelationTargetCursor(Customer.class);
             try {
-                entity.customer__toOne.internalPutTarget(targetCursor);
+                customer.internalPutTarget(targetCursor);
             } finally {
                 targetCursor.close();
             }
@@ -85,31 +86,4 @@ public final long put(Order entity) {
         return __assignedId;
     }
 
-    // TODO @Override
-    protected final void attachEntity(Order entity) {
-        // TODO super.attachEntity(entity);
-        //entity.__boxStore = boxStoreForEntities;
-    }
-
-    // TODO do we need this? @Override
-    protected final boolean isEntityUpdateable() {
-        return true;
-    }
-
-    /** Internal query to resolve the "orders" to-many relationship of Customer. */
-    /* TODO
-    public List<Order> _queryCustomer_Orders(long customerId) {
-        synchronized (this) {
-            if (customer_OrdersQuery == null) {
-                QueryBuilder<Order> queryBuilder = queryBuilder();
-                queryBuilder.where(Properties.customerId.eq(null));
-                customer_OrdersQuery = queryBuilder.build();
-            }
-        }
-        Query<Order> query = customer_OrdersQuery.forCurrentThread();
-        query.setParameter(0, customerId);
-        return query.list();
-    }
-    */
-
 }
diff --git a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java
index 97bd5564..d6723e98 100644
--- a/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java
+++ b/tests/objectbox-java-test/src/main/java/io/objectbox/relation/Order_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,7 +24,8 @@
 import io.objectbox.internal.ToOneGetter;
 import io.objectbox.relation.OrderCursor.Factory;
 
-// THIS CODE IS ADAPTED from generated resources of the test-entity-annotations project
+// NOTE: Instead of updating this by hand, copy changes from the internal integration test project after updating its
+// Customer class.
 
 /**
  * Properties for entity "ORDERS". Can be used for QueryBuilder and for referencing DB names.
@@ -110,10 +110,10 @@ public long getId(Order object) {
         }
     }
 
-    static final RelationInfo<Order, Customer> customer = new RelationInfo<>(Order_.__INSTANCE, Customer_.__INSTANCE, customerId, new ToOneGetter<Order>() {
+    public static final RelationInfo<Order, Customer> customer = new RelationInfo<>(Order_.__INSTANCE, Customer_.__INSTANCE, customerId, new ToOneGetter<Order, Customer>() {
         @Override
         public ToOne<Customer> getToOne(Order object) {
-            return object.customer__toOne;
+            return object.getCustomer();
         }
     });
 
diff --git a/tests/objectbox-java-test/src/main/resources/testentity-index.json b/tests/objectbox-java-test/src/main/resources/testentity-index.json
deleted file mode 100644
index 27a056e1..00000000
--- a/tests/objectbox-java-test/src/main/resources/testentity-index.json
+++ /dev/null
@@ -1,87 +0,0 @@
-{
-  "id": 1,
-  "name": "TestEntity",
-  "metaVersion": 1,
-  "minMetaVersion": 1,
-  "properties": [
-    {
-      "id": 1,
-      "name": "id",
-      "entityId": 1,
-      "offset": 4,
-      "type": 6,
-      "flags": 1
-    },
-    {
-      "id": 2,
-      "name": "simpleBoolean",
-      "entityId": 1,
-      "offset": 6,
-      "type": 1
-    },
-    {
-      "id": 3,
-      "name": "simpleByte",
-      "entityId": 1,
-      "offset": 8,
-      "type": 2
-    },
-    {
-      "id": 4,
-      "name": "simpleShort",
-      "entityId": 1,
-      "offset": 10,
-      "type": 3
-    },
-    {
-      "id": 5,
-      "name": "simpleInt",
-      "entityId": 1,
-      "offset": 12,
-      "type": 5
-    },
-    {
-      "id": 6,
-      "name": "simpleLong",
-      "entityId": 1,
-      "offset": 14,
-      "type": 6
-    },
-    {
-      "id": 7,
-      "name": "simpleFloat",
-      "entityId": 1,
-      "offset": 16,
-      "type": 7
-    },
-    {
-      "id": 8,
-      "name": "simpleDouble",
-      "entityId": 1,
-      "offset": 18,
-      "type": 8
-    },
-    {
-      "id": 9,
-      "name": "simpleString",
-      "entityId": 1,
-      "offset": 20,
-      "type": 9
-    },
-    {
-      "id": 10,
-      "name": "simpleByteArray",
-      "entityId": 1,
-      "offset": 22,
-      "type": 23
-    }
-  ],
-  "indexes": [
-    {
-      "id": 1,
-      "name": "myIndex",
-      "entityId": 1,
-      "propertyIds": [9]
-    }
-  ]
-}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/main/resources/testentity.json b/tests/objectbox-java-test/src/main/resources/testentity.json
deleted file mode 100644
index ea68c75d..00000000
--- a/tests/objectbox-java-test/src/main/resources/testentity.json
+++ /dev/null
@@ -1,79 +0,0 @@
-{
-  "id": 1,
-  "name": "TestEntity",
-  "metaVersion": 1,
-  "minMetaVersion": 1,
-  "properties": [
-    {
-      "id": 1,
-      "name": "id",
-      "entityId": 1,
-      "offset": 4,
-      "type": 6,
-      "flags": 1
-    },
-    {
-      "id": 2,
-      "name": "simpleBoolean",
-      "entityId": 1,
-      "offset": 6,
-      "type": 1
-    },
-    {
-      "id": 3,
-      "name": "simpleByte",
-      "entityId": 1,
-      "offset": 8,
-      "type": 2
-    },
-    {
-      "id": 4,
-      "name": "simpleShort",
-      "entityId": 1,
-      "offset": 10,
-      "type": 3
-    },
-    {
-      "id": 5,
-      "name": "simpleInt",
-      "entityId": 1,
-      "offset": 12,
-      "type": 5
-    },
-    {
-      "id": 6,
-      "name": "simpleLong",
-      "entityId": 1,
-      "offset": 14,
-      "type": 6
-    },
-    {
-      "id": 7,
-      "name": "simpleFloat",
-      "entityId": 1,
-      "offset": 16,
-      "type": 7
-    },
-    {
-      "id": 8,
-      "name": "simpleDouble",
-      "entityId": 1,
-      "offset": 18,
-      "type": 8
-    },
-    {
-      "id": 9,
-      "name": "simpleString",
-      "entityId": 1,
-      "offset": 20,
-      "type": 9
-    },
-    {
-      "id": 10,
-      "name": "simpleByteArray",
-      "entityId": 1,
-      "offset": 22,
-      "type": 23
-    }
-  ]
-}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java
index 42937356..b6ce316a 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/AbstractObjectBoxTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -21,23 +21,47 @@
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Objects;
 import java.util.Random;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
+import java.util.stream.Stream;
 
 import javax.annotation.Nullable;
 
 import io.objectbox.ModelBuilder.EntityBuilder;
 import io.objectbox.ModelBuilder.PropertyBuilder;
+import io.objectbox.annotation.IndexType;
+import io.objectbox.config.DebugFlags;
 import io.objectbox.model.PropertyFlags;
 import io.objectbox.model.PropertyType;
+import io.objectbox.query.InternalAccess;
+
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
 
 public abstract class AbstractObjectBoxTest {
+
+    /**
+     * Turns on additional log output, including logging of transactions or query parameters.
+     */
+    protected static final boolean DEBUG_LOG = false;
+
+    /**
+     * If instead of files the database should be in memory.
+     */
+    protected static final boolean IN_MEMORY = Objects.equals(System.getProperty("obx.inMemory"), "true");
     private static boolean printedVersionsOnce;
 
     protected File boxStoreDir;
@@ -51,47 +75,84 @@ public abstract class AbstractObjectBoxTest {
     long lastEntityUid;
     long lastIndexUid;
 
+    static void printProcessId() {
+        try {
+            // Only if Java 9 is available; e.g. helps to attach native debugger
+            Class<?> processHandleClass = Class.forName("java.lang.ProcessHandle");
+            Object processHandle = processHandleClass.getMethod("current").invoke(null);
+            long pid = (Long) processHandleClass.getMethod("pid").invoke(processHandle);
+            System.out.println("ObjectBox test process ID (pid): " + pid);
+            System.out.flush();
+        } catch (Throwable th) {
+            System.out.println("Could not get process ID (" + th.getMessage() + ")");
+        }
+    }
+
     @Before
     public void setUp() throws IOException {
         Cursor.TRACK_CREATION_STACK = true;
         Transaction.TRACK_CREATION_STACK = true;
+        InternalAccess.queryPublisherLogStates();
 
-        // This works with Android without needing any context
-        File tempFile = File.createTempFile("object-store-test", "");
-        tempFile.delete();
-        boxStoreDir = tempFile;
+        // Note: is logged, so create before logging.
+        boxStoreDir = prepareTempDir("object-store-test");
 
         if (!printedVersionsOnce) {
-            System.out.println("ObjectBox Java version: " + BoxStore.getVersion());
-            System.out.println("ObjectBox Core version: " + BoxStore.getVersionNative());
-            System.out.println("First DB dir: " + boxStoreDir);
             printedVersionsOnce = true;
+            printProcessId();
+            System.out.println("ObjectBox Java SDK version: " + BoxStore.getVersion());
+            System.out.println("ObjectBox Database version: " + BoxStore.getVersionNative());
+            System.out.println("First DB dir: " + boxStoreDir);
+            System.out.println("IN_MEMORY=" + IN_MEMORY);
+            System.out.println("java.version=" + System.getProperty("java.version"));
+            System.out.println("java.vendor=" + System.getProperty("java.vendor"));
+            System.out.println("file.encoding=" + System.getProperty("file.encoding"));
+            System.out.println("sun.jnu.encoding=" + System.getProperty("sun.jnu.encoding"));
         }
 
         store = createBoxStore();
         runExtensiveTests = System.getProperty("extensive-tests") != null;
     }
 
+    /**
+     * This works with Android without needing any context.
+     */
+    protected File prepareTempDir(String prefix) throws IOException {
+        if (IN_MEMORY) {
+            // Instead of random temp directory, use random suffix for each test to avoid re-using existing database
+            // from other tests in case clean-up fails.
+            // Note: tearDown code will still work as the directory does not exist.
+            String randomPart = Long.toUnsignedString(random.nextLong());
+            return new File(BoxStore.IN_MEMORY_PREFIX + prefix + randomPart);
+        } else {
+            File tempFile = File.createTempFile(prefix, "");
+            if (!tempFile.delete()) {
+                throw new IOException("Could not prep temp dir; file delete failed for " + tempFile.getAbsolutePath());
+            }
+            return tempFile;
+        }
+    }
+
     protected BoxStore createBoxStore() {
-        return createBoxStore(false);
+        return createBoxStore(null);
     }
 
-    protected BoxStore createBoxStore(boolean withIndex) {
-        return createBoxStoreBuilder(withIndex).build();
+    protected BoxStore createBoxStore(@Nullable IndexType simpleStringIndexType) {
+        return createBoxStoreBuilder(simpleStringIndexType).build();
     }
 
-    protected BoxStoreBuilder createBoxStoreBuilderWithTwoEntities(boolean withIndex) {
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModelWithTwoEntities(withIndex)).directory(boxStoreDir);
-        builder.debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE);
+    protected BoxStoreBuilder createBoxStoreBuilder(@Nullable IndexType simpleStringIndexType) {
+        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(simpleStringIndexType)).directory(boxStoreDir);
+        if (DEBUG_LOG) builder.debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE);
         builder.entity(new TestEntity_());
-        builder.entity(new TestEntityMinimal_());
         return builder;
     }
 
-    protected BoxStoreBuilder createBoxStoreBuilder(boolean withIndex) {
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(withIndex)).directory(boxStoreDir);
-        builder.debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE);
+    protected BoxStoreBuilder createBoxStoreBuilderWithTwoEntities(boolean withIndex) {
+        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModelWithTwoEntities(withIndex)).directory(boxStoreDir);
+        if (DEBUG_LOG) builder.debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE);
         builder.entity(new TestEntity_());
+        builder.entity(new TestEntityMinimal_());
         return builder;
     }
 
@@ -101,9 +162,9 @@ protected Box<TestEntity> getTestEntityBox() {
 
     @After
     public void tearDown() {
-        // Collect dangling Cursors and TXs before store closes
-        System.gc();
-        System.runFinalization();
+        // Note: do not collect dangling Cursors and Transactions before store closes (using System.gc()
+        // or System.runFinalization()). Tests should mirror user code and do that themselves (calling close())
+        // or rely on the library (through finalizers or BoxStore.close()).
 
         if (store != null) {
             try {
@@ -120,26 +181,29 @@ public void tearDown() {
                 logError("Could not clean up test", e);
             }
         }
-        deleteAllFiles();
+        cleanUpAllFiles(boxStoreDir);
     }
 
-    protected void deleteAllFiles() {
+    /**
+     * Manually clean up any leftover files to prevent interference with other tests.
+     */
+    protected void cleanUpAllFiles(@Nullable File boxStoreDir) {
         if (boxStoreDir != null && boxStoreDir.exists()) {
-            File[] files = boxStoreDir.listFiles();
-            for (File file : files) {
-                delete(file);
+            try (Stream<Path> stream = Files.walk(boxStoreDir.toPath())) {
+                stream.sorted(Comparator.reverseOrder())
+                        .forEach(path -> {
+                            try {
+                                Files.delete(path);
+                            } catch (IOException e) {
+                                logError("Could not delete file", e);
+                                fail("Could not delete file");
+                            }
+                        });
+            } catch (IOException e) {
+                logError("Could not delete file", e);
+                fail("Could not delete file");
             }
-            delete(boxStoreDir);
-        }
-    }
-
-    private boolean delete(File file) {
-        boolean deleted = file.delete();
-        if (!deleted) {
-            file.deleteOnExit();
-            logError("Could not delete " + file.getAbsolutePath());
         }
-        return deleted;
     }
 
     protected void log(String text) {
@@ -161,9 +225,9 @@ protected long time() {
         return System.currentTimeMillis();
     }
 
-    protected byte[] createTestModel(boolean withIndex) {
+    protected byte[] createTestModel(@Nullable IndexType simpleStringIndexType) {
         ModelBuilder modelBuilder = new ModelBuilder();
-        addTestEntity(modelBuilder, withIndex);
+        addTestEntity(modelBuilder, simpleStringIndexType);
         modelBuilder.lastEntityId(lastEntityId, lastEntityUid);
         modelBuilder.lastIndexId(lastIndexId, lastIndexUid);
         return modelBuilder.build();
@@ -171,14 +235,21 @@ protected byte[] createTestModel(boolean withIndex) {
 
     byte[] createTestModelWithTwoEntities(boolean withIndex) {
         ModelBuilder modelBuilder = new ModelBuilder();
-        addTestEntity(modelBuilder, withIndex);
+        addTestEntity(modelBuilder, withIndex ? IndexType.DEFAULT : null);
         addTestEntityMinimal(modelBuilder, withIndex);
         modelBuilder.lastEntityId(lastEntityId, lastEntityUid);
         modelBuilder.lastIndexId(lastIndexId, lastIndexUid);
         return modelBuilder.build();
     }
 
-    private void addTestEntity(ModelBuilder modelBuilder, boolean withIndex) {
+    /**
+     * When not using the {@link #store} of this to create a builder with the default test model.
+     */
+    protected BoxStoreBuilder createBuilderWithTestModel() {
+        return new BoxStoreBuilder(createTestModel(null));
+    }
+
+    private void addTestEntity(ModelBuilder modelBuilder, @Nullable IndexType simpleStringIndexType) {
         lastEntityUid = ++lastUid;
         EntityBuilder entityBuilder = modelBuilder.entity("TestEntity").id(++lastEntityId, lastEntityUid);
         entityBuilder.property("id", PropertyType.Long).id(TestEntity_.id.id, ++lastUid)
@@ -192,11 +263,24 @@ private void addTestEntity(ModelBuilder modelBuilder, boolean withIndex) {
         entityBuilder.property("simpleDouble", PropertyType.Double).id(TestEntity_.simpleDouble.id, ++lastUid);
         PropertyBuilder pb =
                 entityBuilder.property("simpleString", PropertyType.String).id(TestEntity_.simpleString.id, ++lastUid);
-        if (withIndex) {
+        if (simpleStringIndexType != null) {
             lastIndexUid = ++lastUid;
-            pb.flags(PropertyFlags.INDEXED).indexId(++lastIndexId, lastIndexUid);
+            // Since 2.0: default for Strings has changed from INDEXED to INDEX_HASH.
+            int indexFlag;
+            if (simpleStringIndexType == IndexType.VALUE) {
+                indexFlag = PropertyFlags.INDEXED;
+            } else if (simpleStringIndexType == IndexType.HASH64) {
+                indexFlag = PropertyFlags.INDEX_HASH64;
+            } else {
+                indexFlag = PropertyFlags.INDEX_HASH;
+            }
+            log(String.format("Using %s index on TestEntity.simpleString", simpleStringIndexType));
+            pb.flags(indexFlag).indexId(++lastIndexId, lastIndexUid);
         }
         entityBuilder.property("simpleByteArray", PropertyType.ByteVector).id(TestEntity_.simpleByteArray.id, ++lastUid);
+        entityBuilder.property("simpleStringArray", PropertyType.StringVector).id(TestEntity_.simpleStringArray.id, ++lastUid);
+        entityBuilder.property("simpleStringList", PropertyType.StringVector).id(TestEntity_.simpleStringList.id, ++lastUid)
+                .flags(PropertyFlags.NON_PRIMITIVE_TYPE);
 
         // Unsigned integers.
         entityBuilder.property("simpleShortU", PropertyType.Short).id(TestEntity_.simpleShortU.id, ++lastUid)
@@ -206,7 +290,24 @@ private void addTestEntity(ModelBuilder modelBuilder, boolean withIndex) {
         entityBuilder.property("simpleLongU", PropertyType.Long).id(TestEntity_.simpleLongU.id, ++lastUid)
                 .flags(PropertyFlags.UNSIGNED);
 
-        int lastId = TestEntity_.simpleLongU.id;
+        // Flexible properties
+        entityBuilder.property("stringObjectMap", PropertyType.Flex)
+                .id(TestEntity_.stringObjectMap.id, ++lastUid);
+        entityBuilder.property("flexProperty", PropertyType.Flex).id(TestEntity_.flexProperty.id, ++lastUid);
+
+        // Integer and floating point arrays
+        entityBuilder.property("booleanArray", PropertyType.BoolVector).id(TestEntity_.booleanArray.id, ++lastUid);
+        entityBuilder.property("shortArray", PropertyType.ShortVector).id(TestEntity_.shortArray.id, ++lastUid);
+        entityBuilder.property("charArray", PropertyType.CharVector).id(TestEntity_.charArray.id, ++lastUid);
+        entityBuilder.property("intArray", PropertyType.IntVector).id(TestEntity_.intArray.id, ++lastUid);
+        entityBuilder.property("longArray", PropertyType.LongVector).id(TestEntity_.longArray.id, ++lastUid);
+        entityBuilder.property("floatArray", PropertyType.FloatVector).id(TestEntity_.floatArray.id, ++lastUid);
+        entityBuilder.property("doubleArray", PropertyType.DoubleVector).id(TestEntity_.doubleArray.id, ++lastUid);
+
+        // Date property
+        entityBuilder.property("date", PropertyType.Date).id(TestEntity_.date.id, ++lastUid);
+        int lastId = TestEntity_.date.id;
+
         entityBuilder.lastPropertyId(lastId, lastUid);
         addOptionalFlagsToTestEntity(entityBuilder);
         entityBuilder.entityDone();
@@ -231,27 +332,51 @@ private void addTestEntityMinimal(ModelBuilder modelBuilder, boolean withIndex)
     }
 
     protected TestEntity createTestEntity(@Nullable String simpleString, int nr) {
+        boolean simpleBoolean = nr % 2 == 0;
+        short simpleShort = (short) (100 + nr);
+        int simpleLong = 1000 + nr;
+        float simpleFloat = 200 + nr / 10f;
+        double simpleDouble = 2000 + nr / 100f;
+        byte[] simpleByteArray = {1, 2, (byte) nr};
+        String[] simpleStringArray = {simpleString};
+
         TestEntity entity = new TestEntity();
         entity.setSimpleString(simpleString);
         entity.setSimpleInt(nr);
         entity.setSimpleByte((byte) (10 + nr));
-        entity.setSimpleBoolean(nr % 2 == 0);
-        entity.setSimpleShort((short) (100 + nr));
-        entity.setSimpleLong(1000 + nr);
-        entity.setSimpleFloat(200 + nr / 10f);
-        entity.setSimpleDouble(2000 + nr / 100f);
-        entity.setSimpleByteArray(new byte[]{1, 2, (byte) nr});
-        entity.setSimpleShortU((short) (100 + nr));
+        entity.setSimpleBoolean(simpleBoolean);
+        entity.setSimpleShort(simpleShort);
+        entity.setSimpleLong(simpleLong);
+        entity.setSimpleFloat(simpleFloat);
+        entity.setSimpleDouble(simpleDouble);
+        entity.setSimpleByteArray(simpleByteArray);
+        entity.setSimpleStringArray(simpleStringArray);
+        entity.setSimpleStringList(Arrays.asList(simpleStringArray));
+        entity.setSimpleShortU(simpleShort);
         entity.setSimpleIntU(nr);
-        entity.setSimpleLongU(1000 + nr);
+        entity.setSimpleLongU(simpleLong);
+        if (simpleString != null) {
+            Map<String, Object> stringObjectMap = new HashMap<>();
+            stringObjectMap.put(simpleString, simpleString);
+            entity.setStringObjectMap(stringObjectMap);
+        }
+        entity.setFlexProperty(simpleString);
+        entity.setBooleanArray(new boolean[]{simpleBoolean, false, true});
+        entity.setShortArray(new short[]{(short) -(100 + nr), simpleShort});
+        entity.setCharArray(simpleString != null ? simpleString.toCharArray() : null);
+        entity.setIntArray(new int[]{-nr, nr});
+        entity.setLongArray(new long[]{-simpleLong, simpleLong});
+        entity.setFloatArray(new float[]{-simpleFloat, simpleFloat});
+        entity.setDoubleArray(new double[]{-simpleDouble, simpleDouble});
+        entity.setDate(new Date(simpleLong));
         return entity;
     }
 
     protected TestEntity putTestEntity(@Nullable String simpleString, int nr) {
         TestEntity entity = createTestEntity(simpleString, nr);
-        long key = getTestEntityBox().put(entity);
-        assertTrue(key != 0);
-        assertEquals(key, entity.getId());
+        long id = getTestEntityBox().put(entity);
+        assertTrue(id != 0);
+        assertEquals(id, entity.getId());
         return entity;
     }
 
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java
index 0398b1a6..19f464a7 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreBuilderTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,18 +19,37 @@
 import org.junit.Before;
 import org.junit.Test;
 
-import io.objectbox.exception.DbMaxReadersExceededException;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 
+import io.objectbox.exception.DbFullException;
+import io.objectbox.exception.DbMaxDataSizeExceededException;
 
+
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
 
 public class BoxStoreBuilderTest extends AbstractObjectBoxTest {
 
     private BoxStoreBuilder builder;
 
+    private static final String LONG_STRING = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
+
     @Override
     protected BoxStore createBoxStore() {
         // Standard setup of store not required
@@ -38,9 +57,9 @@ protected BoxStore createBoxStore() {
     }
 
     @Before
-    public void setUpBox() {
+    public void setUpBuilder() {
         BoxStore.clearDefaultStore();
-        builder = new BoxStoreBuilder(createTestModel(false)).directory(boxStoreDir);
+        builder = createBuilderWithTestModel().directory(boxStoreDir);
     }
 
     @Test
@@ -70,6 +89,7 @@ public void testClearDefaultStore() {
         boxStore1.close();
         BoxStore boxStore = builder.buildDefault();
         assertSame(boxStore, BoxStore.getDefault());
+        boxStore.close();
     }
 
     @Test(expected = IllegalStateException.class)
@@ -77,9 +97,104 @@ public void testDefaultStoreNull() {
         BoxStore.getDefault();
     }
 
+    @Test
+    public void directoryUnicodePath() throws IOException {
+        File parentTestDir = new File("unicode-test");
+        File testDir = new File(parentTestDir, "Îñţérñåţîöñåļîžåţîờñ");
+        builder.directory(testDir);
+        BoxStore store = builder.build();
+        store.close();
+
+        // Check only expected files and directories exist.
+        // Note: can not compare Path objects, does not appear to work on macOS for unknown reason.
+        Set<String> expectedPaths = new HashSet<>();
+        expectedPaths.add(parentTestDir.toPath().toString());
+        expectedPaths.add(testDir.toPath().toString());
+        Path testDirPath = testDir.toPath();
+        expectedPaths.add(testDirPath.resolve("data.mdb").toString());
+        expectedPaths.add(testDirPath.resolve("lock.mdb").toString());
+        try (Stream<Path> files = Files.walk(parentTestDir.toPath())) {
+            List<Path> unexpectedPaths = files.filter(path -> !expectedPaths.remove(path.toString())).collect(Collectors.toList());
+            if (!unexpectedPaths.isEmpty()) {
+                fail("Found unexpected paths: " + unexpectedPaths);
+            }
+            if (!expectedPaths.isEmpty()) {
+                fail("Missing expected paths: " + expectedPaths);
+            }
+        }
+
+        cleanUpAllFiles(parentTestDir);
+    }
+
+    @Test
+    public void directoryConflictingOptionsError() {
+        // using conflicting option after directory option
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .directory(boxStoreDir)
+                .name("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .directory(boxStoreDir)
+                .baseDirectory(boxStoreDir)
+        );
+
+        // using directory option after conflicting option
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .name("options-test")
+                .directory(boxStoreDir)
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .baseDirectory(boxStoreDir)
+                .directory(boxStoreDir)
+        );
+    }
+
+    @Test
+    public void inMemoryConflictingOptionsError() {
+        // directory-based option after switching to in-memory
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .inMemory("options-test")
+                .name("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .inMemory("options-test")
+                .directory(boxStoreDir)
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .inMemory("options-test")
+                .baseDirectory(boxStoreDir)
+        );
+
+        // in-memory after specifying directory-based option
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .name("options-test")
+                .inMemory("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .directory(boxStoreDir)
+                .inMemory("options-test")
+        );
+        assertThrows(IllegalStateException.class, () -> createBuilderWithTestModel()
+                .baseDirectory(boxStoreDir)
+                .inMemory("options-test")
+        );
+    }
+
+    @Test
+    public void inMemoryCreatesNoFiles() {
+        // let base class clean up store in tearDown method
+        store = createBuilderWithTestModel().inMemory("in-memory-test").build();
+
+        assertFalse(boxStoreDir.exists());
+        assertFalse(new File("memory").exists());
+        assertFalse(new File("memory:").exists());
+        String identifierPart = boxStoreDir.getPath().substring("memory:".length());
+        assertFalse(new File(identifierPart).exists());
+    }
+
     @Test
     public void testMaxReaders() {
-        builder = createBoxStoreBuilder(false);
+        builder = createBoxStoreBuilder(null);
         store = builder.maxReaders(1).build();
         final Exception[] exHolder = {null};
         final Thread thread = new Thread(() -> {
@@ -107,4 +222,125 @@ public void testMaxReaders() {
 //        assertEquals(DbMaxReadersExceededException.class, exHolder[0].getClass());
     }
 
+    @Test
+    public void readOnly() {
+        // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)
+        byte[] model = createTestModel(null);
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        store = builder.build();
+        store.close();
+
+        // Then re-open database with same model as read-only.
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.readOnly();
+        store = builder.build();
+
+        assertTrue(store.isReadOnly());
+    }
+
+    @Test
+    public void maxSize_invalidValues_throw() {
+        // Max data larger than max database size throws.
+        builder.maxSizeInKByte(10);
+        IllegalArgumentException exSmaller = assertThrows(
+                IllegalArgumentException.class,
+                () -> builder.maxDataSizeInKByte(11)
+        );
+        assertEquals("maxDataSizeInKByte must be smaller than maxSizeInKByte.", exSmaller.getMessage());
+
+        // Max database size smaller than max data size throws.
+        builder.maxDataSizeInKByte(9);
+        IllegalArgumentException exLarger = assertThrows(
+                IllegalArgumentException.class,
+                () -> builder.maxSizeInKByte(8)
+        );
+        assertEquals("maxSizeInKByte must be larger than maxDataSizeInKByte.", exLarger.getMessage());
+    }
+
+    @Test
+    public void maxFileSize() {
+        assumeFalse(IN_MEMORY); // no max size support for in-memory
+
+        // To avoid frequently changing the limit choose one high enough to insert at least one object successfully,
+        // then keep inserting until the limit is hit.
+        builder = createBoxStoreBuilder(null);
+        builder.maxSizeInKByte(150);
+        store = builder.build();
+
+        putTestEntity(LONG_STRING, 1); // Should work
+
+        boolean dbFullExceptionThrown = false;
+        for (int i = 2; i < 1000; i++) {
+            TestEntity testEntity = createTestEntity(LONG_STRING, i);
+            try {
+                getTestEntityBox().put(testEntity);
+            } catch (DbFullException e) {
+                dbFullExceptionThrown = true;
+                break;
+            }
+        }
+        assertTrue("DbFullException was not thrown",  dbFullExceptionThrown);
+
+        // Check re-opening with larger size allows to insert again
+        store.close();
+        builder.maxSizeInKByte(200);
+        store = builder.build();
+        getTestEntityBox().put(createTestEntity(LONG_STRING, 1000));
+    }
+
+    @Test
+    public void maxDataSize() {
+        builder = createBoxStoreBuilder(null);
+        builder.maxDataSizeInKByte(1);
+        store = builder.build();
+
+        // Put until max data size is reached
+        TestEntity testEntity1 = putTestEntity(LONG_STRING, 1);
+        TestEntity testEntity2 = createTestEntity(LONG_STRING, 2);
+        DbMaxDataSizeExceededException maxDataExc = assertThrows(
+                DbMaxDataSizeExceededException.class,
+                () -> getTestEntityBox().put(testEntity2)
+        );
+        assertEquals("Exceeded user-set maximum by [bytes]: 560", maxDataExc.getMessage());
+
+        // Remove to get below max data size, then put again.
+        getTestEntityBox().remove(testEntity1);
+        getTestEntityBox().put(testEntity2);
+
+        // Alternatively, re-open with larger max data size.
+        store.close();
+        builder.maxDataSizeInKByte(2);
+        store = builder.build();
+        putTestEntity(LONG_STRING, 3);
+    }
+
+
+    @Test
+    public void testCreateClone() {
+        builder = createBoxStoreBuilder(null);
+        store = builder.build();
+        putTestEntity(LONG_STRING, 1);
+
+        BoxStoreBuilder clonedBuilder = builder.createClone("-cloned");
+        assertEquals(clonedBuilder.directory.getAbsolutePath(), boxStoreDir.getAbsolutePath() + "-cloned");
+
+        BoxStore clonedStore = clonedBuilder.build();
+        assertNotNull(clonedStore);
+        assertNotSame(store, clonedStore);
+        assertArrayEquals(store.getAllEntityTypeIds(), clonedStore.getAllEntityTypeIds());
+
+        Box<TestEntity> boxOriginal = store.boxFor(TestEntity.class);
+        assertEquals(1, boxOriginal.count());
+        Box<TestEntity> boxClone = clonedStore.boxFor(TestEntity.class);
+        assertEquals(0, boxClone.count());
+
+        boxClone.put(createTestEntity("I'm a clone", 2));
+        boxClone.put(createTestEntity("I'm a clone, too", 3));
+        assertEquals(2, boxClone.count());
+        assertEquals(1, boxOriginal.count());
+
+        store.close();
+        clonedStore.close();
+        clonedStore.deleteAllFiles();
+    }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreLogTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreLogTest.java
new file mode 100644
index 00000000..4ed1a932
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreLogTest.java
@@ -0,0 +1,90 @@
+/*
+ * Copyright 2024 ObjectBox Ltd. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import org.junit.Test;
+
+import java.io.ByteArrayOutputStream;
+import java.io.PrintStream;
+import java.io.UnsupportedEncodingException;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.annotation.IndexType;
+
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+
+/**
+ * Sets a custom error output stream to assert log messages of {@link BoxStore}.
+ */
+public class BoxStoreLogTest extends AbstractObjectBoxTest {
+
+    private ByteArrayOutputStream errOutput;
+
+    @Override
+    protected BoxStoreBuilder createBoxStoreBuilder(@Nullable IndexType simpleStringIndexType) {
+        BoxStoreBuilder builder = super.createBoxStoreBuilder(simpleStringIndexType);
+        errOutput = new ByteArrayOutputStream();
+        builder.setErrorOutput(new PrintStream(errOutput));
+        return builder;
+    }
+
+    @Test
+    public void close_activeThreadPool_printsError() throws UnsupportedEncodingException {
+        // Submit two threads, one to the internal pool, that run longer
+        // than BoxStore.close waits on the pool to terminate
+        new Thread(() -> {
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException ignored) {
+            }
+        }).start();
+        store.internalScheduleThread(() -> {
+            try {
+                Thread.sleep(2000);
+            } catch (InterruptedException ignored) {
+            }
+        });
+        // Close store to trigger thread pool shutdown, store waits 1 second for shutdown
+        store.close();
+
+        String errOutput = this.errOutput.toString("UTF-8");
+        assertTrue(errOutput.contains("ObjectBox thread pool not terminated in time"));
+        assertTrue(errOutput.contains("=== BEGIN OF DUMP ==="));
+        assertTrue(errOutput.contains("=== END OF DUMP ==="));
+        // Check that only pool threads or threads with stack traces that contain the objectbox package are printed
+        String[] lines = errOutput.split("\n");
+        String checkStackTrace = null;
+        for (String line : lines) {
+            if (line.startsWith("Thread:")) {
+                if (checkStackTrace != null) {
+                    fail("Expected stack trace to contain class in objectbox package");
+                }
+                if (!line.contains("ObjectBox-")) {
+                    checkStackTrace = line;
+                }
+            } else if (checkStackTrace != null) {
+                if (line.contains("objectbox")) {
+                    checkStackTrace = null;
+                }
+            }
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java
index 43367c71..27fd8d74 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,32 +17,26 @@
 package io.objectbox;
 
 import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
 
 import java.io.File;
 import java.util.concurrent.Callable;
-
-import javax.annotation.Nullable;
+import java.util.concurrent.RejectedExecutionException;
 
 import io.objectbox.exception.DbException;
 
-import static org.junit.Assert.*;
-
-public class BoxStoreTest extends AbstractObjectBoxTest {
 
-    @Test
-    public void testUnalignedMemoryAccess() {
-        BoxStore.testUnalignedMemoryAccess();
-    }
-
-    @Test
-    public void testClose() {
-        assertFalse(store.isClosed());
-        store.close();
-        assertTrue(store.isClosed());
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
 
-        // Double close should be fine
-        store.close();
-    }
+public class BoxStoreTest extends AbstractObjectBoxTest {
 
     @Test
     public void testEmptyTransaction() {
@@ -84,34 +78,135 @@ public void testCloseThreadResources() {
         assertNotSame(reader, reader3);
     }
 
-    @Test(expected = DbException.class)
-    public void testPreventTwoBoxStoresWithSameFileOpenend() {
-        createBoxStore();
+    @Test
+    public void testClose() {
+        // This test suite uses a single entity (TestEntity) by default
+        // and all other tests close the store after being done. So should be 1.
+        assertEquals(1, BoxStore.nativeGloballyActiveEntityTypes());
+
+        BoxStore store = this.store;
+        assertFalse(store.isClosed());
+        store.close();
+        assertTrue(store.isClosed());
+        // Assert native Entity instances are not leaked.
+        assertEquals(0, BoxStore.nativeGloballyActiveEntityTypes());
+
+        // Double close should be fine
+        store.close();
+
+        // Internal thread pool is shut down.
+        assertTrue(store.internalThreadPool().isShutdown());
+        assertTrue(store.internalThreadPool().isTerminated());
+
+        // Can still obtain a box (but not use it).
+        store.boxFor(TestEntity.class);
+        store.closeThreadResources();
+        //noinspection ResultOfMethodCallIgnored
+        store.getObjectBrowserPort();
+        store.isObjectBrowserRunning();
+        //noinspection ResultOfMethodCallIgnored
+        store.isDebugRelations();
+        store.internalQueryAttempts();
+        store.internalFailedReadTxAttemptCallback();
+        //noinspection ResultOfMethodCallIgnored
+        store.getSyncClient();
+        store.setSyncClient(null);
+
+        // Methods using the native store should throw.
+        assertThrowsStoreIsClosed(store::getDbSize);
+        assertThrowsStoreIsClosed(store::getDbSizeOnDisk);
+        assertThrowsStoreIsClosed(store::beginTx);
+        assertThrowsStoreIsClosed(store::beginReadTx);
+        assertThrowsStoreIsClosed(store::isReadOnly);
+        assertThrowsStoreIsClosed(store::removeAllObjects);
+        assertThrowsStoreIsClosed(() -> store.runInTx(() -> {
+        }));
+        assertThrowsStoreIsClosed(() -> store.runInReadTx(() -> {
+        }));
+        assertThrowsStoreIsClosed(() -> store.callInReadTxWithRetry(() -> null,
+                3, 1, true));
+        assertThrowsStoreIsClosed(() -> store.callInReadTx(() -> null));
+        assertThrowsStoreIsClosed(() -> store.callInTx(() -> null));
+        // callInTxNoException wraps in RuntimeException
+        RuntimeException runtimeException = assertThrows(RuntimeException.class, () -> store.callInTxNoException(() -> null));
+        assertEquals("java.lang.IllegalStateException: Store is closed", runtimeException.getMessage());
+        // Internal thread pool is shut down as part of closing store, should no longer accept new work.
+        assertThrows(RejectedExecutionException.class, () -> store.runInTxAsync(() -> {}, null));
+        assertThrows(RejectedExecutionException.class, () -> store.callInTxAsync(() -> null, null));
+        assertThrowsStoreIsClosed(store::diagnose);
+        assertThrowsStoreIsClosed(() -> store.validate(0, false));
+        assertThrowsStoreIsClosed(store::cleanStaleReadTransactions);
+        assertThrowsStoreIsClosed(store::subscribe);
+        assertThrowsStoreIsClosed(() -> store.subscribe(TestEntity.class));
+        assertThrowsStoreIsClosed(store::startObjectBrowser);
+        assertThrowsStoreIsClosed(() -> store.startObjectBrowser(12345));
+        assertThrowsStoreIsClosed(() -> store.startObjectBrowser("http://127.0.0.1"));
+        // assertThrowsStoreIsClosed(store::stopObjectBrowser); // Requires mocking, not testing for now.
+        assertThrowsStoreIsClosed(() -> store.setDbExceptionListener(null));
+        // Internal thread pool is shut down as part of closing store, should no longer accept new work.
+        assertThrows(RejectedExecutionException.class, () -> store.internalScheduleThread(() -> {}));
+        assertThrowsStoreIsClosed(() -> store.setDebugFlags(0));
+        assertThrowsStoreIsClosed(() -> store.panicModeRemoveAllObjects(TestEntity_.__ENTITY_ID));
+        assertThrowsStoreIsClosed(store::getNativeStore);
+    }
+
+    private void assertThrowsStoreIsClosed(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("Store is closed", ex.getMessage());
     }
 
     @Test
-    public void testOpenSameBoxStoreAfterClose() {
+    public void openSamePath_fails() {
+        DbException ex = assertThrows(DbException.class, this::createBoxStore);
+        assertTrue(ex.getMessage().contains("Another BoxStore is still open for this directory"));
+    }
+
+    @Test
+    public void openSamePath_afterClose_works() {
         store.close();
-        createBoxStore();
+        // Assert native Entity instances are not leaked.
+        assertEquals(0, BoxStore.nativeGloballyActiveEntityTypes());
+
+        BoxStore store2 = createBoxStore();
+        store2.close();
+        // Assert native Entity instances are not leaked.
+        assertEquals(0, BoxStore.nativeGloballyActiveEntityTypes());
+    }
+
+    @Test
+    public void openSamePath_closedByFinalizer_works() {
+        System.out.println("Removing reference to " + store);
+        store = null;
+
+        // When another Store is still open using the same path, a checker thread is started that periodically triggers
+        // garbage collection and finalization in the VM, which here should close store and allow store2 to be opened.
+        // Note that user code should not rely on this, see notes on BoxStore.finalize().
+        BoxStore store2 = createBoxStore();
+        store2.close();
+        System.out.println("Closed " + store2);
     }
 
     @Test
     public void testOpenTwoBoxStoreTwoFiles() {
         File boxStoreDir2 = new File(boxStoreDir.getAbsolutePath() + "-2");
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(false)).directory(boxStoreDir2);
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir2);
         builder.entity(new TestEntity_());
     }
 
     @Test
     public void testDeleteAllFiles() {
+        // Note: for in-memory can not really assert database is gone,
+        // e.g. using sizeOnDisk is not possible after closing the store from Java.
         closeStoreForTest();
     }
 
     @Test
     public void testDeleteAllFiles_staticDir() {
+        assumeFalse(IN_MEMORY);
         closeStoreForTest();
+
         File boxStoreDir2 = new File(boxStoreDir.getAbsolutePath() + "-2");
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(false)).directory(boxStoreDir2);
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir2);
         BoxStore store2 = builder.build();
         store2.close();
 
@@ -122,15 +217,21 @@ public void testDeleteAllFiles_staticDir() {
 
     @Test
     public void testDeleteAllFiles_baseDirName() {
+        assumeFalse(IN_MEMORY);
+
         closeStoreForTest();
         File basedir = new File("test-base-dir");
         String name = "mydb";
-        basedir.mkdir();
+        if (!basedir.exists()) {
+            if (!basedir.mkdir()) {
+                fail("Failed to create test directory.");
+            }
+        }
         assertTrue(basedir.isDirectory());
         File dbDir = new File(basedir, name);
         assertFalse(dbDir.exists());
 
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(false)).baseDirectory(basedir).name(name);
+        BoxStoreBuilder builder = createBuilderWithTestModel().baseDirectory(basedir).name(name);
         BoxStore store2 = builder.build();
         store2.close();
 
@@ -167,7 +268,9 @@ public void removeAllObjects() {
     }
 
     private void closeStoreForTest() {
-        assertTrue(boxStoreDir.exists());
+        if (!IN_MEMORY) {
+            assertTrue(boxStoreDir.exists());
+        }
         store.close();
         assertTrue(store.deleteAllFiles());
         assertFalse(boxStoreDir.exists());
@@ -193,7 +296,7 @@ public void testCallInReadTxWithRetry_callback() {
         final int[] countHolder = {0};
         final int[] countHolderCallback = {0};
 
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(false)).directory(boxStoreDir)
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir)
                 .failedReadTxAttemptCallback((result, error) -> {
                     assertNotNull(error);
                     countHolderCallback[0]++;
@@ -209,10 +312,62 @@ private Callable<String> createTestCallable(final int[] countHolder) {
         return () -> {
             int count = ++countHolder[0];
             if (count < 5) {
-                throw new DbException("Count: " + count);
+                throw new DbException("This exception IS expected. Count: " + count);
             }
             return "42";
         };
     }
 
+    @Test
+    public void testSizeOnDisk() {
+        // Note: initial database does have a non-zero (file) size.
+        assertTrue(store.getDbSize() > 0);
+
+        long sizeOnDisk = store.getDbSizeOnDisk();
+        // Check the file size is at least a reasonable value
+        assertTrue("Size is not reasonable", IN_MEMORY ? sizeOnDisk == 0 : sizeOnDisk > 10000 /* 10 KB */);
+
+        // Check the file size increases after inserting
+        putTestEntities(10);
+        long sizeOnDiskAfterPut = store.getDbSizeOnDisk();
+        assertTrue("Size did not increase", IN_MEMORY ? sizeOnDiskAfterPut == 0 : sizeOnDiskAfterPut > sizeOnDisk);
+    }
+
+    @Test
+    public void validate() {
+        putTestEntities(100);
+
+        // Note: not implemented for in-memory, returns 0.
+        // No limit.
+        long validated = store.validate(0, true);
+        assertTrue(IN_MEMORY ? validated == 0 : validated > 2 /* must be larger than with pageLimit == 1, see below */);
+
+        // With limit.
+        validated = store.validate(1, true);
+        // 2 because the first page doesn't contain any actual data?
+        assertEquals(IN_MEMORY ? 0 : 2, validated);
+    }
+
+    @Test
+    public void testIsObjectBrowserAvailable() {
+        assertFalse(BoxStore.isObjectBrowserAvailable());
+    }
+
+    @Test
+    public void testSysProc() {
+        long vmRss = BoxStore.sysProcStatusKb("VmRSS");
+        long memAvailable = BoxStore.sysProcMeminfoKb("MemAvailable");
+
+        final String osName = System.getProperty("os.name");
+        if (osName.toLowerCase().contains("linux")) {
+            System.out.println("VmRSS: " + vmRss);
+            System.out.println("MemAvailable: " + memAvailable);
+            assertTrue(vmRss > 0);
+            assertTrue(memAvailable > 0);
+        } else {
+            assertEquals(0, vmRss);
+            assertEquals(0, memAvailable);
+        }
+    }
+
 }
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt
new file mode 100644
index 00000000..116998ac
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreTestK.kt
@@ -0,0 +1,110 @@
+package io.objectbox
+
+import io.objectbox.kotlin.awaitCallInTx
+import io.objectbox.kotlin.boxFor
+import io.objectbox.kotlin.newCachedThreadPoolDispatcher
+import io.objectbox.kotlin.newFixedThreadPoolDispatcher
+import kotlinx.coroutines.ExecutorCoroutineDispatcher
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.withContext
+import org.junit.Assert.*
+import org.junit.Test
+import java.util.concurrent.Executors
+
+
+class BoxStoreTestK : AbstractObjectBoxTest() {
+
+    /**
+     * This is mostly to test the expected syntax works without errors or warnings.
+     */
+    @Test
+    fun boxFor() {
+        val boxJavaApi = testEntityBox
+        val box = store.boxFor<TestEntity>()
+        assertEquals(boxJavaApi, box)
+
+        // Note the difference to Java API: TestEntity::class.java
+        val box2 = store.boxFor(TestEntity::class)
+        assertEquals(boxJavaApi, box2)
+    }
+
+    @Test
+    fun awaitCallInTx() {
+        val box = store.boxFor<TestEntity>()
+        runTest {
+            // put
+            val id = store.awaitCallInTx {
+                box.put(createTestEntity("Hello", 1))
+            }
+            assertEquals(1, id!!)
+
+            // get
+            val note = store.awaitCallInTx {
+                box.get(id)
+            }
+            assertEquals("Hello", note!!.simpleString)
+        }
+    }
+
+    /**
+     * This appears to duplicate [ObjectBoxThreadPoolExecutorTest.executor_cleansThreadResources], however,
+     * this makes sure that a coroutine continues to be executed like a runnable and clean up of
+     * [ObjectBoxThreadPoolExecutor] continues to work in this case.
+     */
+    @Test
+    fun dispatcherBackedByObjectBoxExecutor_cleansThreadResources() {
+        runTest {
+            // Use a single thread to make it easy to check thread-local Box resources have been cleaned up
+            val dispatcher = store.newFixedThreadPoolDispatcher(1)
+
+            val hasReaderCursor = withContext(dispatcher) {
+                val box = store.boxFor<TestEntity>()
+                val entity = createTestEntity("dispatcher-test", 1)
+                val id = box.put(entity)
+                box.get(id)
+                box.hasReaderCursorForCurrentThread()
+            }
+            // Verify that a thread-local reader cursor was created
+            assertTrue(hasReaderCursor)
+
+            // Check the thread-local reader cursor was released after the previous coroutine was executed
+            val hasReaderCursorAfter = withContext(dispatcher) {
+                store.boxFor<TestEntity>().hasReaderCursorForCurrentThread()
+            }
+            assertFalse(hasReaderCursorAfter)
+        }
+    }
+
+    @Test
+    fun newCachedThreadPoolDispatcher_works() {
+        runTest {
+            assertDispatcher(store.newCachedThreadPoolDispatcher())
+            assertDispatcher(store.newCachedThreadPoolDispatcher(Executors.defaultThreadFactory()))
+        }
+    }
+
+    @Test
+    fun newFixedThreadPoolDispatcher_works() {
+        runTest {
+            assertDispatcher(store.newFixedThreadPoolDispatcher(2))
+            assertDispatcher(store.newFixedThreadPoolDispatcher(2, Executors.defaultThreadFactory()))
+        }
+    }
+
+    /**
+     * Quickly checks the pre-configured dispatchers work.
+     */
+    private suspend fun assertDispatcher(dispatcher: ExecutorCoroutineDispatcher) {
+        dispatcher.use { dispatcher ->
+            // Create at least a write and a read transaction
+            val testEntity: TestEntity? = withContext(dispatcher) {
+                val box = store.boxFor<TestEntity>()
+                val entity = createTestEntity("dispatcher-test", 1)
+                val id = box.put(entity)
+
+                box.get(id)
+            }
+            assertEquals("dispatcher-test", testEntity!!.simpleString)
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreValidationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreValidationTest.java
new file mode 100644
index 00000000..88e5e28c
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxStoreValidationTest.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright 2023-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import org.greenrobot.essentials.io.IoUtils;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+import io.objectbox.config.ValidateOnOpenModePages;
+import io.objectbox.exception.FileCorruptException;
+import io.objectbox.exception.PagesCorruptException;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
+
+/**
+ * Tests validation (and recovery) options on opening a store.
+ */
+public class BoxStoreValidationTest extends AbstractObjectBoxTest {
+
+    private BoxStoreBuilder builder;
+
+    @Override
+    protected BoxStore createBoxStore() {
+        // Standard setup of store not required
+        return null;
+    }
+
+    @Before
+    public void setUpBuilder() {
+        BoxStore.clearDefaultStore();
+        builder = createBuilderWithTestModel().directory(boxStoreDir);
+    }
+
+    @Test
+    public void validateOnOpen() {
+        // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)
+        byte[] model = createTestModel(null);
+        long id = buildNotCorruptedDatabase(model);
+
+        // Then re-open database with validation and ensure db is operational
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.entity(new TestEntity_());
+        builder.validateOnOpen(ValidateOnOpenModePages.Full);
+        store = builder.build();
+        assertNotNull(getTestEntityBox().get(id));
+        getTestEntityBox().put(new TestEntity(0));
+    }
+
+
+    @Test
+    public void validateOnOpenCorruptFile() throws IOException {
+        assumeFalse(IN_MEMORY);
+
+        File dir = prepareTempDir("object-store-test-corrupted");
+        prepareBadDataFile(dir, "corrupt-pageno-in-branch-data.mdb");
+
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpen(ValidateOnOpenModePages.Full);
+
+        @SuppressWarnings("resource")
+        FileCorruptException ex = assertThrows(PagesCorruptException.class, () -> builder.build());
+        assertEquals("Validating pages failed (page not found)", ex.getMessage());
+
+        // Clean up
+        cleanUpAllFiles(dir);
+    }
+
+    @Test
+    public void usePreviousCommitWithCorruptFile() throws IOException {
+        assumeFalse(IN_MEMORY);
+
+        File dir = prepareTempDir("object-store-test-corrupted");
+        prepareBadDataFile(dir, "corrupt-pageno-in-branch-data.mdb");
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpen(ValidateOnOpenModePages.Full).usePreviousCommit();
+        store = builder.build();
+        String diagnoseString = store.diagnose();
+        assertTrue(diagnoseString.contains("entries=2"));
+        store.validate(0, true);
+        store.close();
+        assertTrue(store.deleteAllFiles());
+    }
+
+    @Test
+    public void usePreviousCommitAfterFileCorruptException() throws IOException {
+        assumeFalse(IN_MEMORY);
+
+        File dir = prepareTempDir("object-store-test-corrupted");
+        prepareBadDataFile(dir, "corrupt-pageno-in-branch-data.mdb");
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpen(ValidateOnOpenModePages.Full);
+        try {
+            store = builder.build();
+            fail("Should have thrown");
+        } catch (PagesCorruptException e) {
+            builder.usePreviousCommit();
+            store = builder.build();
+        }
+
+        String diagnoseString = store.diagnose();
+        assertTrue(diagnoseString.contains("entries=2"));
+        store.validate(0, true);
+        store.close();
+        assertTrue(store.deleteAllFiles());
+    }
+
+    @Test
+    public void validateOnOpenKv() {
+        // Create a database first; we must create the model only once (ID/UID sequences would be different 2nd time)
+        byte[] model = createTestModel(null);
+        long id = buildNotCorruptedDatabase(model);
+
+        // Then re-open database with validation and ensure db is operational
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.entity(new TestEntity_());
+        builder.validateOnOpenKv();
+        store = builder.build();
+        assertNotNull(getTestEntityBox().get(id));
+        getTestEntityBox().put(new TestEntity(0));
+    }
+
+    @Test
+    public void validateOnOpenKvCorruptFile() throws IOException {
+        assumeFalse(IN_MEMORY);
+        
+        File dir = prepareTempDir("obx-store-validate-kv-corrupted");
+        prepareBadDataFile(dir, "corrupt-keysize0-data.mdb");
+
+        builder = BoxStoreBuilder.createDebugWithoutModel().directory(dir);
+        builder.validateOnOpenKv();
+
+        @SuppressWarnings("resource")
+        FileCorruptException ex = assertThrows(FileCorruptException.class, () -> builder.build());
+        assertEquals("KV validation failed; key is empty (KV pair number: 1, key size: 0, data size: 112)",
+                ex.getMessage());
+
+        // Clean up
+        cleanUpAllFiles(dir);
+    }
+
+    /**
+     * Returns the id of the inserted test entity.
+     */
+    private long buildNotCorruptedDatabase(byte[] model) {
+        builder = new BoxStoreBuilder(model).directory(boxStoreDir);
+        builder.entity(new TestEntity_());
+        store = builder.build();
+
+        TestEntity object = new TestEntity(0);
+        object.setSimpleString("hello hello");
+        long id = getTestEntityBox().put(object);
+        store.close();
+        return id;
+    }
+
+    /**
+     * Copies the given file from resources to the given directory as "data.mdb".
+     */
+    private void prepareBadDataFile(File dir, String resourceName) throws IOException {
+        assertTrue(dir.mkdir());
+        File badDataFile = new File(dir, "data.mdb");
+        try (InputStream badIn = getClass().getResourceAsStream(resourceName)) {
+            assertNotNull(badIn);
+            try (FileOutputStream badOut = new FileOutputStream(badDataFile)) {
+                IoUtils.copyAllBytes(badIn, badOut);
+            }
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java
index 60edf593..fc669a14 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/BoxTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -20,11 +20,20 @@
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collection;
+import java.util.Date;
 import java.util.List;
 import java.util.Map;
 
-import static org.junit.Assert.*;
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 public class BoxTest extends AbstractObjectBoxTest {
 
@@ -37,15 +46,131 @@ public void setUpBox() {
 
     @Test
     public void testPutAndGet() {
+        final String simpleString = "sunrise";
+        final int simpleInt = 1977;
+
+        TestEntity entity = createTestEntity(simpleString, simpleInt);
+        long id = box.put(entity);
+        assertTrue(id != 0);
+        assertEquals(id, entity.getId());
+
+        short valShort = 100 + simpleInt;
+        long valLong = 1000 + simpleInt;
+        float valFloat = 200 + simpleInt / 10f;
+        double valDouble = 2000 + simpleInt / 100f;
+        byte[] valByteArray = {1, 2, (byte) simpleInt};
+
+        TestEntity entityRead = box.get(id);
+        assertNotNull(entityRead);
+        assertEquals(id, entityRead.getId());
+        assertEquals(simpleString, entityRead.getSimpleString());
+        assertEquals(simpleInt, entityRead.getSimpleInt());
+        assertEquals((byte) (10 + simpleInt), entityRead.getSimpleByte());
+        assertFalse(entityRead.getSimpleBoolean());
+        assertEquals(valShort, entityRead.getSimpleShort());
+        assertEquals(valLong, entityRead.getSimpleLong());
+        assertEquals(valFloat, entityRead.getSimpleFloat(), 0);
+        assertEquals(valDouble, entityRead.getSimpleDouble(), 0);
+        assertArrayEquals(valByteArray, entityRead.getSimpleByteArray());
+        String[] expectedStringArray = new String[]{simpleString};
+        assertArrayEquals(expectedStringArray, entityRead.getSimpleStringArray());
+        assertEquals(Arrays.asList(expectedStringArray), entityRead.getSimpleStringList());
+        assertEquals((short) (100 + simpleInt), entityRead.getSimpleShortU());
+        assertEquals(simpleInt, entityRead.getSimpleIntU());
+        assertEquals(1000 + simpleInt, entityRead.getSimpleLongU());
+        assertEquals(1, entityRead.getStringObjectMap().size());
+        assertEquals(simpleString, entityRead.getStringObjectMap().get(simpleString));
+        assertEquals(simpleString, entityRead.getFlexProperty());
+        assertArrayEquals(new boolean[]{false, false, true}, entity.getBooleanArray());
+        assertArrayEquals(new short[]{(short) -valShort, valShort}, entity.getShortArray());
+        assertArrayEquals(simpleString.toCharArray(), entity.getCharArray());
+        assertArrayEquals(new int[]{-simpleInt, simpleInt}, entity.getIntArray());
+        assertArrayEquals(new long[]{-valLong, valLong}, entity.getLongArray());
+        assertArrayEquals(new float[]{-valFloat, valFloat}, entityRead.getFloatArray(), 0);
+        assertArrayEquals(new double[]{-valDouble, valDouble}, entity.getDoubleArray(), 0);
+        assertEquals(new Date(1000 + simpleInt), entity.getDate());
+    }
+
+    @Test
+    public void testPutAndGet_defaultOrNullValues() {
+        long id = box.put(new TestEntity());
+
+        TestEntity defaultEntity = box.get(id);
+        assertNull(defaultEntity.getSimpleString());
+        assertEquals(0, defaultEntity.getSimpleInt());
+        assertEquals((byte) 0, defaultEntity.getSimpleByte());
+        assertFalse(defaultEntity.getSimpleBoolean());
+        assertEquals((short) 0, defaultEntity.getSimpleShort());
+        assertEquals(0, defaultEntity.getSimpleLong());
+        assertEquals(0, defaultEntity.getSimpleFloat(), 0);
+        assertEquals(0, defaultEntity.getSimpleDouble(), 0);
+        assertNull(defaultEntity.getSimpleByteArray());
+        assertNull(defaultEntity.getSimpleStringArray());
+        assertNull(defaultEntity.getSimpleStringList());
+        assertEquals(0, defaultEntity.getSimpleShortU());
+        assertEquals(0, defaultEntity.getSimpleIntU());
+        assertEquals(0, defaultEntity.getSimpleLongU());
+        assertNull(defaultEntity.getStringObjectMap());
+        assertNull(defaultEntity.getFlexProperty());
+        assertNull(defaultEntity.getBooleanArray());
+        assertNull(defaultEntity.getShortArray());
+        assertNull(defaultEntity.getCharArray());
+        assertNull(defaultEntity.getIntArray());
+        assertNull(defaultEntity.getLongArray());
+        assertNull(defaultEntity.getFloatArray());
+        assertNull(defaultEntity.getDoubleArray());
+        assertNull(defaultEntity.getDate());
+    }
+
+    // Note: There is a similar test using the Cursor API directly (which is deprecated) in CursorTest.
+    @Test
+    public void testPut_notAssignedId_fails() {
         TestEntity entity = new TestEntity();
-        entity.setSimpleInt(1977);
-        long key = box.put(entity);
-        assertTrue(key != 0);
-        assertEquals(key, entity.getId());
+        // Set ID that was not assigned
+        entity.setId(1);
+        IllegalArgumentException ex = assertThrows(IllegalArgumentException.class, () -> box.put(entity));
+        assertEquals("ID is higher or equal to internal ID sequence: 1 (vs. 1). Use ID 0 (zero) to insert new objects.", ex.getMessage());
+    }
 
-        TestEntity entityRead = box.get(key);
+    @Test
+    public void testPut_assignedId_inserts() {
+        long id = box.put(new TestEntity());
+        box.remove(id);
+        // Put with previously assigned ID should insert
+        TestEntity entity = new TestEntity();
+        entity.setId(id);
+        box.put(entity);
+        assertEquals(1L, box.count());
+    }
+
+    @Test
+    public void testPutStrings_withNull_ignoresNull() {
+        final String[] stringArray = new String[]{"sunrise", null, "sunset"};
+        final String[] expectedStringArray = new String[]{"sunrise", "sunset"};
+
+        TestEntity entity = new TestEntity();
+        entity.setSimpleStringArray(stringArray);
+        entity.setSimpleStringList(Arrays.asList(stringArray));
+        box.put(entity);
+
+        TestEntity entityRead = box.get(entity.getId());
         assertNotNull(entityRead);
-        assertEquals(1977, entityRead.getSimpleInt());
+        assertArrayEquals(expectedStringArray, entityRead.getSimpleStringArray());
+        assertEquals(Arrays.asList(expectedStringArray), entityRead.getSimpleStringList());
+    }
+
+    @Test
+    public void testPutStrings_onlyNull_isEmpty() {
+        TestEntity entity = new TestEntity();
+        final String[] stringArray = new String[]{null};
+        entity.setSimpleStringArray(stringArray);
+        entity.setSimpleStringList(Arrays.asList(stringArray));
+        box.put(entity);
+
+        TestEntity entityRead = box.get(entity.getId());
+        assertNotNull(entityRead);
+        assertArrayEquals(new String[]{}, entityRead.getSimpleStringArray());
+        assertEquals(new ArrayList<>(), entityRead.getSimpleStringList());
     }
 
     @Test
@@ -79,9 +204,11 @@ public void testPutGetUpdateGetRemove() {
         assertEquals(value2, entityRead.getSimpleString());
 
         // and remove it
+        assertTrue(box.contains(id));
         assertTrue(box.remove(id));
         assertNull(box.get(id));
         assertFalse(box.remove(id));
+        assertFalse(box.contains(id));
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java
index 18700c29..9bcc4e27 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorBytesTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java
index eb194e3f..98d43ab0 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/CursorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,18 +18,27 @@
 
 import org.junit.Test;
 
-import java.io.IOException;
-import java.util.List;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ThreadLocalRandom;
 import java.util.concurrent.TimeUnit;
 
-import static org.junit.Assert.*;
+import io.objectbox.annotation.IndexType;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
 
 public class CursorTest extends AbstractObjectBoxTest {
 
     @Override
     protected BoxStore createBoxStore() {
-        return createBoxStore(true);
+        // Note: can not use DEFAULT as tests use deprecated cursor.lookupKeyUsingIndex method
+        // which expects a value based index.
+        return createBoxStore(IndexType.VALUE);
     }
 
     @Test
@@ -48,15 +57,20 @@ public void testPutAndGetEntity() {
         transaction.abort();
     }
 
-    @Test(expected = IllegalArgumentException.class)
+    @Test
     public void testPutEntityWithInvalidId() {
         TestEntity entity = new TestEntity();
         entity.setId(777);
         Transaction transaction = store.beginTx();
         Cursor<TestEntity> cursor = transaction.createCursor(TestEntity.class);
+
         try {
-            cursor.put(entity);
+            IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                    () -> cursor.put(entity));
+            assertEquals(ex.getMessage(), "ID is higher or equal to internal ID sequence: 777 (vs. 1)." +
+                    " Use ID 0 (zero) to insert new objects.");
         } finally {
+            // Always clean up, even if assertions fail, to avoid misleading clean-up errors.
             cursor.close();
             transaction.close();
         }
@@ -214,17 +228,37 @@ public void testClose() {
         }
     }
 
+    /**
+     * Begin the first write-TX and ensure the second one blocks until the first one is closed.
+     * A secondary test goal is to check races of a closing TX and a closing store.
+     */
     @Test
     public void testWriteTxBlocksOtherWriteTx() throws InterruptedException {
+        // To change the likelihood of the TX vs store closing race, close the store using one of 3 different variants.
+        // Assign and print the randomly chosen variant beforehand so it does not mess with thread timings later.
+        // Warning: test variant 2 only manually, it will close the write-TX from a non-owner thread (in BoxStore.close)
+        // where the native database is expected to panic.
+        int closeStoreVariant = ThreadLocalRandom.current().nextInt(2 /* 3 - test variant 2 manually, see above */);
+        System.out.println("Closing store variant: " + closeStoreVariant);
+
         long time = System.currentTimeMillis();
         Transaction tx = store.beginTx();
         long duration = System.currentTimeMillis() - time; // Usually 0 on desktop
         final CountDownLatch latchBeforeBeginTx = new CountDownLatch(1);
         final CountDownLatch latchAfterBeginTx = new CountDownLatch(1);
+        final CountDownLatch latchCloseStoreInMainThread = closeStoreVariant != 0 ? new CountDownLatch(1) : null;
         new Thread(() -> {
             latchBeforeBeginTx.countDown();
             Transaction tx2 = store.beginTx();
             latchAfterBeginTx.countDown();
+
+            if (closeStoreVariant != 0) {
+                try {
+                    assertTrue(latchCloseStoreInMainThread.await(5, TimeUnit.SECONDS));
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("Interrupted", e);
+                }
+            }
             tx2.close();
         }).start();
         assertTrue(latchBeforeBeginTx.await(1, TimeUnit.SECONDS));
@@ -232,6 +266,16 @@ public void testWriteTxBlocksOtherWriteTx() throws InterruptedException {
         assertFalse(latchAfterBeginTx.await(waitTime, TimeUnit.MILLISECONDS));
         tx.close();
         assertTrue(latchAfterBeginTx.await(waitTime * 2, TimeUnit.MILLISECONDS));
+
+        // closeStoreVariant == 0: not latch waiting, close store when tearing down test
+        if (closeStoreVariant == 1) {
+            // This variant tries to close the store and the TX at the same time.
+            latchCloseStoreInMainThread.countDown();
+            store.close();  // Maybe this runs a tiny bit before the close() in teardown(?)
+        } else if (closeStoreVariant == 2) {
+            store.close();  // Enforces closing the store before the TX.
+            latchCloseStoreInMainThread.countDown();
+        }
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java
index 37c81423..77cd0a77 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/DebugCursorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt b/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt
new file mode 100644
index 00000000..34b4972a
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/FlowTest.kt
@@ -0,0 +1,38 @@
+package io.objectbox
+
+import app.cash.turbine.test
+import io.objectbox.kotlin.flow
+import io.objectbox.kotlin.query
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+
+class FlowTest : AbstractObjectBoxTest() {
+
+    @Test
+    fun flow_box() {
+        runBlocking {
+            store.flow(TestEntity::class.java).test {
+                assertEquals(TestEntity::class.java, awaitItem())
+                putTestEntities(1)
+                // Note: awaitItem suspends until event, so no need to wait on OBX publisher thread.
+                assertEquals(TestEntity::class.java, awaitItem())
+                cancel() // expect no more events
+            }
+        }
+    }
+
+    @Test
+    fun flow_query() {
+        runBlocking {
+            testEntityBox.query {}.flow().test {
+                assertEquals(0, awaitItem().size)
+                putTestEntities(1)
+                // Note: awaitItem suspends until event, so no need to wait on OBX publisher thread.
+                assertEquals(1, awaitItem().size)
+                cancel() // expect no more events
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/FunctionalTestSuite.java b/tests/objectbox-java-test/src/test/java/io/objectbox/FunctionalTestSuite.java
deleted file mode 100644
index b7f3c8b5..00000000
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/FunctionalTestSuite.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package io.objectbox;
-
-import io.objectbox.index.IndexReaderRenewTest;
-import io.objectbox.query.LazyListTest;
-import io.objectbox.query.PropertyQueryTest;
-import io.objectbox.query.QueryFilterComparatorTest;
-import io.objectbox.query.QueryObserverTest;
-import io.objectbox.query.QueryTest;
-import io.objectbox.relation.RelationEagerTest;
-import io.objectbox.relation.RelationTest;
-import io.objectbox.relation.ToManyStandaloneTest;
-import io.objectbox.relation.ToManyTest;
-import io.objectbox.relation.ToOneTest;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
-import org.junit.runners.Suite.SuiteClasses;
-
-/** Used to run tests on CI, excludes performance tests. */
-@RunWith(Suite.class)
-@SuiteClasses({
-        BoxTest.class,
-        BoxStoreTest.class,
-        BoxStoreBuilderTest.class,
-        CursorTest.class,
-        CursorBytesTest.class,
-        DebugCursorTest.class,
-        LazyListTest.class,
-        NonArgConstructorTest.class,
-        IndexReaderRenewTest.class,
-        ObjectClassObserverTest.class,
-        PropertyQueryTest.class,
-        QueryFilterComparatorTest.class,
-        QueryObserverTest.class,
-        QueryTest.class,
-        RelationTest.class,
-        RelationEagerTest.class,
-        ToManyStandaloneTest.class,
-        ToManyTest.class,
-        ToOneTest.class,
-        TransactionTest.class,
-})
-public class FunctionalTestSuite {
-}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java
index 06462ff2..d9b12f2b 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/JniBasicsTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -44,8 +44,7 @@ public void testReturnIntArray() {
     public void testCreateAndDeleteIntArray() {
         // Lower Android versions have a ReferenceTable with 1024 entries only
         for (int i = 0; i < 2000; i++) {
-            assertTrue(JniTest.createAndDeleteIntArray());
-            System.out.print(i);
+            assertTrue("Failed at iteration " + i, JniTest.createAndDeleteIntArray());
         }
     }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java
index e6c4e3bc..26d37484 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/NonArgConstructorTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,12 +19,11 @@
 import org.junit.Before;
 import org.junit.Test;
 
-import java.util.Arrays;
-
 import io.objectbox.ModelBuilder.EntityBuilder;
 import io.objectbox.model.EntityFlags;
 
 
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertTrue;
@@ -56,6 +55,8 @@ public void testPutAndGet() {
         entity.setSimpleLong(789437444354L);
         entity.setSimpleShort((short) 233);
         entity.setSimpleString("foo");
+        String[] strings = {"foo", "bar"};
+        entity.setSimpleStringArray(strings);
         long key = box.put(entity);
 
         TestEntity entityRead = box.get(key);
@@ -68,8 +69,9 @@ public void testPutAndGet() {
         assertEquals(789437444354L, entityRead.getSimpleLong());
         assertEquals(3.14f, entityRead.getSimpleFloat(), 0.000001f);
         assertEquals(3.141f, entityRead.getSimpleDouble(), 0.000001);
-        assertTrue(Arrays.equals(bytes, entityRead.getSimpleByteArray()));
+        assertArrayEquals(bytes, entityRead.getSimpleByteArray());
         assertEquals("foo", entityRead.getSimpleString());
+        assertArrayEquals(strings, entityRead.getSimpleStringArray());
     }
 
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectBoxThreadPoolExecutorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectBoxThreadPoolExecutorTest.java
new file mode 100644
index 00000000..9c05293c
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectBoxThreadPoolExecutorTest.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright © 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox;
+
+import org.junit.Test;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests {@link ObjectBoxThreadPoolExecutor}.
+ */
+public class ObjectBoxThreadPoolExecutorTest extends AbstractObjectBoxTest {
+
+    @Test
+    public void executor_cleansThreadResources() throws Exception {
+        // Use a single thread to make it easy to check thread-local Box resources have been cleaned up
+        ObjectBoxThreadPoolExecutor executor = store.newFixedThreadPoolExecutor(1);
+
+        try {
+            // Submit a runnable that uses a Box API that will create a thread-local reader cursor
+            Future<Object[]> readResult = executor.submit(() -> {
+                Box<TestEntity> box = store.boxFor(TestEntity.class);
+                TestEntity entity = new TestEntity();
+                entity.setSimpleString("executor-test");
+                long id = box.put(entity);
+
+                TestEntity testEntity = box.get(id); // Creates a thread-local reader cursor
+
+                boolean hasReaderCursor = box.hasReaderCursorForCurrentThread();
+
+                return new Object[]{testEntity, hasReaderCursor};
+            });
+            Object[] result = readResult.get(1, TimeUnit.SECONDS);
+
+            TestEntity testEntity = (TestEntity) result[0];
+            assertNotNull(testEntity);
+            assertEquals("executor-test", testEntity.getSimpleString());
+
+            // Verify that a thread-local reader cursor was created
+            Boolean hasReaderCursor = (Boolean) result[1];
+            assertTrue(hasReaderCursor);
+
+            // Check the thread-local reader cursor has been released after the previous runnable was executed
+            Future<Boolean> cleanedResult = executor.submit(() -> {
+                Box<TestEntity> box = store.boxFor(TestEntity.class);
+                return box.hasReaderCursorForCurrentThread();
+            });
+            assertFalse(cleanedResult.get(1, TimeUnit.SECONDS));
+        } finally {
+            executor.shutdown();
+            assertTrue(executor.awaitTermination(1, TimeUnit.SECONDS));
+        }
+    }
+
+    @Test
+    public void newCachedThreadPoolExecutor_works() throws Exception {
+        assertExecutor(store.newCachedThreadPoolExecutor());
+        assertExecutor(store.newCachedThreadPoolExecutor(Executors.defaultThreadFactory()));
+    }
+
+    @Test
+    public void newFixedThreadPoolExecutor_works() throws Exception {
+        assertExecutor(store.newFixedThreadPoolExecutor(2));
+        assertExecutor(store.newFixedThreadPoolExecutor(2, Executors.defaultThreadFactory()));
+    }
+
+    /**
+     * Quickly checks the pre-configured executors works.
+     */
+    private void assertExecutor(ObjectBoxThreadPoolExecutor executor) throws Exception {
+        try {
+            // Create at least a write and a read transaction
+            Future<TestEntity> future = executor.submit(() -> {
+                Box<TestEntity> box = store.boxFor(TestEntity.class);
+                TestEntity entity = new TestEntity();
+                entity.setSimpleString("executor-test");
+                long id = box.put(entity);
+
+                return box.get(id);
+            });
+            TestEntity testEntity = future.get(1, TimeUnit.SECONDS);
+            assertNotNull(testEntity);
+            assertEquals("executor-test", testEntity.getSimpleString());
+        } finally {
+            executor.shutdown();
+            assertTrue(executor.awaitTermination(1, TimeUnit.SECONDS));
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java
index d0730bac..409d70ca 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/ObjectClassObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,13 @@
 
 package io.objectbox;
 
+import io.objectbox.query.QueryObserverTest;
+import io.objectbox.reactive.DataObserver;
+import io.objectbox.reactive.DataSubscription;
+import io.objectbox.reactive.DataTransformer;
+import io.objectbox.reactive.RunWithParam;
+import io.objectbox.reactive.Scheduler;
+import io.objectbox.reactive.SubscriptionBuilder;
 import org.junit.Before;
 import org.junit.Test;
 
@@ -23,17 +30,10 @@
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
-import io.objectbox.reactive.DataObserver;
-import io.objectbox.reactive.DataSubscription;
-import io.objectbox.reactive.DataTransformer;
-import io.objectbox.reactive.ErrorObserver;
-import io.objectbox.reactive.RunWithParam;
-import io.objectbox.reactive.Scheduler;
-import io.objectbox.reactive.SubscriptionBuilder;
-
-
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertTrue;
@@ -153,6 +153,53 @@ public void testTwoObjectClassesChanged_oneClassObserver(boolean weak) throws In
         assertNoStaleObservers();
     }
 
+    @Test
+    public void observer_transactionInCallback_completesAndTriggersObserver() throws InterruptedException {
+        RecursiveTestObserver testObserver = new RecursiveTestObserver(store);
+        DataSubscription subscription = store.subscribe(TestEntityMinimal.class)
+                .onlyChanges() // Do not publish on subscribing.
+                .observer(testObserver);
+
+        // Put data to so observer is called.
+        Box<TestEntityMinimal> box = store.boxFor(TestEntityMinimal.class);
+        box.put(new TestEntityMinimal(0, "Written by test"));
+
+        // Observer is called, puts data, is called again, puts data again.
+        assertTrue(testObserver.latch.await(100, TimeUnit.MILLISECONDS));
+
+        assertEquals(3, box.count());
+        assertEquals("Written by test", box.get(1).getText());
+        assertEquals("Written by observer 1", box.get(2).getText());
+        assertEquals("Written by observer 2", box.get(3).getText());
+
+        // Clean up.
+        subscription.cancel();
+    }
+
+    private static class RecursiveTestObserver implements DataObserver<Class<TestEntityMinimal>> {
+
+        private final BoxStore store;
+        private int count = 0;
+        CountDownLatch latch = new CountDownLatch(2);
+
+        RecursiveTestObserver(BoxStore store) {
+            this.store = store;
+        }
+
+        @Override
+        public void onData(Class<TestEntityMinimal> data) {
+            if (latch.getCount() == 0) {
+                System.out.println("RecursiveTestObserver: DONE");
+                return;
+            }
+            count++;
+            System.out.println("RecursiveTestObserver: writing " + count);
+            store.runInTx(() -> store.boxFor(TestEntityMinimal.class)
+                    .put(new TestEntityMinimal(0, "Written by observer " + count)));
+            latch.countDown();
+        }
+    }
+
     @Test
     public void testTransform() throws InterruptedException {
         testTransform(null);
@@ -195,6 +242,42 @@ private void testTransform(TestScheduler scheduler) throws InterruptedException
         assertEquals(0, objectCounts.size());
     }
 
+    /**
+     * There is an identical test asserting QueryPublisher at
+     * {@link QueryObserverTest#transform_inOrderOfPublish()}.
+     */
+    @Test
+    public void transform_inOrderOfPublish() {
+        final CountDownLatch latch = new CountDownLatch(2);
+        final AtomicBoolean isLongTransform = new AtomicBoolean(true);
+        final List<Integer> placing = new CopyOnWriteArrayList<>();
+
+        // Make first transformation take longer than second.
+        DataSubscription subscription = store.subscribe(TestEntity.class).transform(source -> {
+            if (isLongTransform.compareAndSet(true, false)) {
+                // Wait long enough so publish triggered by transaction
+                // can overtake publish triggered during observer() call.
+                Thread.sleep(200);
+                return 1; // First, during observer() call.
+            }
+            return 2; // Second, due to transaction.
+        }).observer(data -> {
+            placing.add(data);
+            latch.countDown();
+        });
+
+        // Trigger publish due to transaction.
+        store.runInTx(() -> putTestEntities(1));
+
+        assertLatchCountedDown(latch, 3);
+        subscription.cancel();
+
+        // Second publish request should still deliver second.
+        assertEquals(2, placing.size());
+        assertEquals(1, (int) placing.get(0));
+        assertEquals(2, (int) placing.get(1));
+    }
+
     @Test
     public void testScheduler() {
         TestScheduler scheduler = new TestScheduler();
@@ -221,7 +304,7 @@ int counter() {
         }
 
         @Override
-        public <T> void run(RunWithParam runnable, T param) {
+        public <T> void run(RunWithParam<T> runnable, T param) {
             counter.incrementAndGet();
             runnable.run(param);
         }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java b/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java
index ba5e2f98..c7f89b01 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/TestUtils.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -33,6 +33,20 @@
 
 public class TestUtils {
 
+    public static boolean isWindows() {
+        final String osName = System.getProperty("os.name").toLowerCase();
+        return osName.contains("windows");
+    }
+
+    /**
+     * Returns true if the JVM this code runs on is in 32-bit mode,
+     * so may not necessarily mean the system has a 32-bit architecture.
+     */
+    public static boolean is32BitJVM() {
+        final String bitness = System.getProperty("sun.arch.data.model");
+        return "32".equals(bitness);
+    }
+
     public static String loadFile(String filename) {
         try {
             InputStream in = openInputStream("/" + filename);
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java
index 540e6179..181a27dc 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/TransactionTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2024 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,20 +18,38 @@
 
 import org.junit.Ignore;
 import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
 
+import java.io.IOException;
+import java.util.ArrayList;
 import java.util.concurrent.Callable;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
 import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.ThreadPoolExecutor;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
-
-import javax.annotation.Nullable;
+import java.util.concurrent.atomic.AtomicReference;
 
 import io.objectbox.exception.DbException;
 import io.objectbox.exception.DbExceptionListener;
 import io.objectbox.exception.DbMaxReadersExceededException;
+import io.objectbox.query.Query;
+
 
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.junit.Assume.assumeFalse;
 
 public class TransactionTest extends AbstractObjectBoxTest {
 
@@ -41,9 +59,9 @@ private void prepareOneEntryWith1230() {
         KeyValueCursor cursor = transaction.createKeyValueCursor();
         cursor.put(123, new byte[]{1, 2, 3, 0});
         cursor.close();
-        assertEquals(true, transaction.isActive());
+        assertTrue(transaction.isActive());
         transaction.commit();
-        assertEquals(false, transaction.isActive());
+        assertFalse(transaction.isActive());
     }
 
     @Test
@@ -83,17 +101,17 @@ public void testReadTransactionWhileWriting() {
         cursorRead.close();
 
         // commit writing
-        assertEquals(true, txRead.isReadOnly());
-        assertEquals(false, txWrite.isReadOnly());
+        assertTrue(txRead.isReadOnly());
+        assertFalse(txWrite.isReadOnly());
 
-        assertEquals(true, txWrite.isActive());
+        assertTrue(txWrite.isActive());
         txWrite.commit();
-        assertEquals(false, txWrite.isActive());
+        assertFalse(txWrite.isActive());
 
         // commit reading
-        assertEquals(true, txRead.isActive());
+        assertTrue(txRead.isActive());
         txRead.abort();
-        assertEquals(false, txRead.isActive());
+        assertFalse(txRead.isActive());
 
         // start reading again and get the new value
         txRead = store.beginReadTx();
@@ -118,7 +136,7 @@ public void testTransactionReset() {
         assertArrayEquals(new byte[]{3, 2, 1, 0}, cursor.get(123));
         cursor.close();
         transaction.reset();
-        assertEquals(true, transaction.isActive());
+        assertTrue(transaction.isActive());
 
         cursor = transaction.createKeyValueCursor();
         assertArrayEquals(new byte[]{1, 2, 3, 0}, cursor.get(123));
@@ -145,7 +163,7 @@ public void testTransactionReset() {
         assertArrayEquals(new byte[]{3, 2, 1, 0}, cursor.get(123));
         cursor.close();
         transaction.reset();
-        assertEquals(true, transaction.isActive());
+        assertTrue(transaction.isActive());
 
         cursor = transaction.createKeyValueCursor();
         assertArrayEquals(new byte[]{3, 2, 1, 0}, cursor.get(123));
@@ -153,28 +171,28 @@ public void testTransactionReset() {
         transaction.abort();
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCreateCursorAfterAbortException() {
         Transaction tx = store.beginReadTx();
         tx.abort();
-        tx.createKeyValueCursor();
+        IllegalStateException ex = assertThrows(IllegalStateException.class, tx::createKeyValueCursor);
+        assertTrue(ex.getMessage().contains("TX is not active anymore"));
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCommitAfterAbortException() {
         Transaction tx = store.beginTx();
         tx.abort();
-        tx.commit();
+        IllegalStateException ex = assertThrows(IllegalStateException.class, tx::commit);
+        assertTrue(ex.getMessage().contains("TX is not active anymore"));
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testCommitReadTxException() {
         Transaction tx = store.beginReadTx();
-        try {
-            tx.commit();
-        } finally {
-            tx.abort();
-        }
+        IllegalStateException ex = assertThrows(IllegalStateException.class, tx::commit);
+        assertEquals("Read transactions may not be committed - use abort instead", ex.getMessage());
+        tx.abort();
     }
 
     @Test
@@ -183,13 +201,34 @@ public void testCommitReadTxException_exceptionListener() {
         DbExceptionListener exceptionListener = e -> exs[0] = e;
         Transaction tx = store.beginReadTx();
         store.setDbExceptionListener(exceptionListener);
-        try {
-            tx.commit();
-            fail("Should have thrown");
-        } catch (IllegalStateException e) {
-            tx.abort();
-            assertSame(e, exs[0]);
-        }
+        IllegalStateException e = assertThrows(IllegalStateException.class, tx::commit);
+        tx.abort();
+        assertSame(e, exs[0]);
+    }
+
+    @Test
+    public void testCancelExceptionOutsideDbExceptionListener() {
+        IllegalStateException e = assertThrows(
+                IllegalStateException.class,
+                DbExceptionListener::cancelCurrentException
+        );
+        assertEquals("Canceling Java exceptions can only be done from inside exception listeners",
+                e.getMessage());
+    }
+
+    @Test
+    public void testCommitReadTxException_cancelException() {
+        final Exception[] exs = {null};
+        DbExceptionListener exceptionListener = e -> {
+            if (exs[0] != null) throw new RuntimeException("Called more than once");
+            exs[0] = e;
+            DbExceptionListener.cancelCurrentException();
+        };
+        Transaction tx = store.beginReadTx();
+        store.setDbExceptionListener(exceptionListener);
+        tx.commit();
+        tx.abort();
+        assertNotNull(exs[0]);
     }
 
     /*
@@ -260,16 +299,75 @@ public void testClose() {
         assertFalse(tx.isClosed());
         tx.close();
         assertTrue(tx.isClosed());
+        assertFalse(tx.isActive());
 
         // Double close should be fine
         tx.close();
 
-        try {
-            tx.reset();
-            fail("Should have thrown");
-        } catch (IllegalStateException e) {
-            // OK
+        // Calling other methods should throw.
+        assertThrowsTxClosed(tx::commit);
+        assertThrowsTxClosed(tx::commitAndClose);
+        assertThrowsTxClosed(tx::abort);
+        assertThrowsTxClosed(tx::reset);
+        assertThrowsTxClosed(tx::recycle);
+        assertThrowsTxClosed(tx::renew);
+        assertThrowsTxClosed(tx::createKeyValueCursor);
+        assertThrowsTxClosed(() -> tx.createCursor(TestEntity.class));
+        assertThrowsTxClosed(tx::isRecycled);
+    }
+
+    private void assertThrowsTxClosed(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("Transaction is closed", ex.getMessage());
+    }
+
+    @Test
+    public void nativeCallInTx_storeIsClosed_throws() throws InterruptedException {
+        // Ignore test on Windows, it was observed to crash with EXCEPTION_ACCESS_VIOLATION
+        assumeFalse(TestUtils.isWindows());
+
+        System.out.println("NOTE This test will cause \"Transaction is still active\" and \"Irrecoverable memory error\" error logs!");
+
+        CountDownLatch callableIsReady = new CountDownLatch(1);
+        CountDownLatch storeIsClosed = new CountDownLatch(1);
+        CountDownLatch callableIsDone = new CountDownLatch(1);
+        AtomicReference<Exception> callableException = new AtomicReference<>();
+
+        // Goal: be just passed closed checks on the Java side, about to call a native query API.
+        // Then close the Store, then call the native API. The native API call should not crash the VM.
+        Callable<Void> waitingCallable = () -> {
+            Box<TestEntity> box = store.boxFor(TestEntity.class);
+            Query<TestEntity> query = box.query().build();
+            // Obtain Cursor handle before closing the Store as getActiveTxCursor() has a closed check
+            long cursorHandle = InternalAccess.getActiveTxCursorHandle(box);
+            
+            callableIsReady.countDown();
+            try {
+                if (!storeIsClosed.await(5, TimeUnit.SECONDS)) {
+                    throw new IllegalStateException("Store did not close within 5 seconds");
+                }
+                // Call native query API within the transaction (opened by callInReadTx below)
+                io.objectbox.query.InternalAccess.nativeFindFirst(query, cursorHandle);
+                query.close();
+            } catch (Exception e) {
+                callableException.set(e);
+            }
+            callableIsDone.countDown();
+            return null;
+        };
+        new Thread(() -> store.callInReadTx(waitingCallable)).start();
+
+        callableIsReady.await();
+        store.close();
+        storeIsClosed.countDown();
+
+        if (!callableIsDone.await(10, TimeUnit.SECONDS)) {
+            fail("Callable did not finish within 10 seconds");
         }
+        Exception exception = callableException.get();
+        assertTrue(exception instanceof IllegalStateException);
+        // Note: the "State" at the end of the message may be different depending on platform, so only assert prefix
+        assertTrue(exception.getMessage().startsWith("Illegal Store instance detected! This is a severe usage error that must be fixed."));
     }
 
     @Test
@@ -325,12 +423,90 @@ public void testCallInReadTx() {
     }
 
     @Test
-    public void testRunInReadTxAndThenPut() {
+    public void testRunInTx_closesActiveTxCursor() {
         final Box<TestEntity> box = getTestEntityBox();
-        store.runInReadTx(box::count);
-        // Verify that box does not hang on to the read-only TX by doing a put
+        AtomicBoolean hasCursorInTx = new AtomicBoolean(false);
+        store.runInTx(() -> {
+            box.count(); // Call Box API that creates a reader/activeTxCursor
+            hasCursorInTx.set(box.hasActiveTxCursorForCurrentThread());
+        });
+        // Verify a cursor for the active tx was created
+        assertTrue(hasCursorInTx.get());
+        // Check it was released
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the runnable throws
+        try {
+            store.runInTx(() -> {
+                box.count();
+                throw new IllegalStateException("Throw in transaction");
+            });
+        } catch (IllegalStateException ignored) {}
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    @Test
+    public void testCallInTx_closesActiveTxCursor() throws Exception {
+        final Box<TestEntity> box = getTestEntityBox();
+        Boolean hasCursorInTx = store.callInTx(() -> {
+            box.count(); // Call Box API that creates a reader/activeTxCursor
+            return box.hasActiveTxCursorForCurrentThread();
+        });
+        // Verify a cursor for the active tx was created
+        assertTrue(hasCursorInTx);
+        // Check it was released
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the callable throws
+        try {
+            store.callInTx(() -> {
+                box.count();
+                throw new IllegalStateException("Throw in transaction");
+            });
+        } catch (IllegalStateException ignored) {}
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    @Test
+    public void testRunInReadTx_closesActiveTxCursor() {
+        final Box<TestEntity> box = getTestEntityBox();
+        store.runInReadTx(box::count); // Call Box API that creates a reader/activeTxCursor
+        // Verify that box does not hang on to the read-only TX: if it would, count() would re-use the cursor/tx from
+        // above and not see the put object.
+        putTestEntityAndExpectCount(1);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the runnable throws
+        assertThrows(IllegalStateException.class, () -> store.runInReadTx(() -> {
+            box.count();
+            throw new IllegalStateException("Throw in transaction");
+        }));
+        putTestEntityAndExpectCount(2);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    @Test
+    public void testCallInReadTx_closesActiveTxCursor() {
+        final Box<TestEntity> box = getTestEntityBox();
+        store.callInReadTx(box::count); // Call Box API that creates a reader/activeTxCursor
+        // Verify that box does not hang on to the read-only TX: if it would, count() would re-use the cursor/tx from
+        // above and not see the put object.
+        putTestEntityAndExpectCount(1);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+
+        // Verify the same in case the callable throws
+        assertThrows(IllegalStateException.class, () -> store.callInReadTx(() -> {
+            box.count();
+            throw new IllegalStateException("Throw in transaction");
+        }));
+        putTestEntityAndExpectCount(2);
+        assertFalse(box.hasActiveTxCursorForCurrentThread());
+    }
+
+    private void putTestEntityAndExpectCount(int expectedCount) {
+        Box<TestEntity> box = getTestEntityBox();
         box.put(new TestEntity());
-        assertEquals(1, box.count());
+        assertEquals(expectedCount, box.count());
     }
 
     @Test
@@ -346,9 +522,13 @@ public void testRunInReadTx_recursiveWriteTxFails() {
         });
     }
 
-    @Test(expected = DbException.class)
+    @Test
     public void testRunInReadTx_putFails() {
-        store.runInReadTx(() -> getTestEntityBox().put(new TestEntity()));
+        DbException e = assertThrows(
+                DbException.class,
+                () -> store.runInReadTx(() -> getTestEntityBox().put(new TestEntity()))
+        );
+        assertEquals("Cannot put in read transaction", e.getMessage());
     }
 
     @Test
@@ -419,5 +599,140 @@ public void testCallInTxAsync_Error() throws InterruptedException {
         assertNotNull(result);
     }
 
+    @Test
+    public void transaction_unboundedThreadPool() throws Exception {
+        runThreadPoolReaderTest(
+                () -> {
+                    Transaction tx = store.beginReadTx();
+                    tx.close();
+                }
+        );
+    }
+
+    @Test
+    public void runInReadTx_unboundedThreadPool() throws Exception {
+        runThreadPoolReaderTest(
+                () -> store.runInReadTx(() -> {
+                })
+        );
+    }
+
+    @Test
+    public void callInReadTx_unboundedThreadPool() throws Exception {
+        runThreadPoolReaderTest(
+                () -> store.callInReadTx(() -> 1)
+        );
+    }
+
+    @Test
+    public void boxReader_unboundedThreadPool() throws Exception {
+        runThreadPoolReaderTest(
+                () -> {
+                    store.boxFor(TestEntity.class).count();
+                    store.closeThreadResources();
+                }
+        );
+    }
+
+    /**
+     * Tests that a reader is available again after a transaction is closed on a thread.
+     * To not exceed max readers this test simply does not allow any two threads
+     * to have an active transaction at the same time, e.g. there should always be only one active reader.
+     */
+    private void runThreadPoolReaderTest(Runnable runnable) throws Exception {
+        // Replace default store: transaction logging disabled and specific max readers.
+        tearDown();
+        store = createBoxStoreBuilder(null)
+                .maxReaders(100)
+                .debugFlags(0)
+                .noReaderThreadLocals()  // This is the essential flag to make this test work
+                .build();
+
+        // Unbounded (but throttled) thread pool so number of threads run exceeds max readers.
+        int numThreads = TestUtils.isWindows() ? 300 : 1000; // Less on Windows; had some resource issues on Windows CI
+        ExecutorService pool = Executors.newCachedThreadPool();
+
+        ArrayList<Future<Integer>> txTasks = new ArrayList<>(10000);
+        final Object lock = new Object();
+        for (int i = 0; i < 10000; i++) {
+            final int txNumber = i;
+            txTasks.add(pool.submit(() -> {
+                // Lock to ensure no two threads have an active transaction at the same time.
+                synchronized (lock) {
+                    runnable.run();
+                    return txNumber;
+                }
+            }));
+            if (pool instanceof ThreadPoolExecutor && ((ThreadPoolExecutor) pool).getActiveCount() > numThreads) {
+                Thread.sleep(1); // Throttle processing to limit thread resources
+            }
+        }
+
+        //Iterate through all the txTasks and make sure all transactions succeeded.
+        for (Future<Integer> txTask : txTasks) {
+            txTask.get(1, TimeUnit.MINUTES);  // 1s would be enough for normally, but use 1 min to allow debug sessions
+        }
+    }
+
+    @Test
+    public void runInTx_forwardsException() {
+        // Exception from callback is forwarded.
+        RuntimeException e = assertThrows(
+                RuntimeException.class,
+                () -> store.runInTx(() -> {
+                    throw new RuntimeException("Thrown inside callback");
+                })
+        );
+        assertEquals("Thrown inside callback", e.getMessage());
+
+        // Can create a new transaction afterward.
+        store.runInTx(() -> store.boxFor(TestEntity.class).count());
+    }
+
+    @Test
+    public void runInReadTx_forwardsException() {
+        // Exception from callback is forwarded.
+        RuntimeException e = assertThrows(
+                RuntimeException.class,
+                () -> store.runInReadTx(() -> {
+                    throw new RuntimeException("Thrown inside callback");
+                })
+        );
+        assertEquals("Thrown inside callback", e.getMessage());
+
+        // Can create a new transaction afterward.
+        store.runInReadTx(() -> store.boxFor(TestEntity.class).count());
+    }
+
+    @Test
+    public void callInTx_forwardsException() throws Exception {
+        // Exception from callback is forwarded.
+        Exception e = assertThrows(
+                Exception.class,
+                () -> store.callInTx(() -> {
+                    throw new Exception("Thrown inside callback");
+                })
+        );
+        assertEquals("Thrown inside callback", e.getMessage());
+
+        // Can create a new transaction afterward.
+        store.callInTx(() -> store.boxFor(TestEntity.class).count());
+    }
 
+    @Test
+    public void callInReadTx_forwardsException() {
+        // Exception from callback is forwarded, but wrapped inside a RuntimeException.
+        RuntimeException e = assertThrows(
+                RuntimeException.class,
+                () -> store.callInReadTx(() -> {
+                    throw new IOException("Thrown inside callback");
+                })
+        );
+        assertEquals("Callable threw exception", e.getMessage());
+        assertTrue(e.getCause() instanceof IOException);
+        assertEquals("Thrown inside callback", e.getCause().getMessage());
+
+        // Can create a new transaction afterward.
+        store.callInReadTx(() -> store.boxFor(TestEntity.class).count());
+    }
 }
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8HashIndexTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8HashIndexTest.java
new file mode 100644
index 00000000..1e506386
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8HashIndexTest.java
@@ -0,0 +1,15 @@
+package io.objectbox;
+
+import io.objectbox.annotation.IndexType;
+
+/**
+ * Same as {@link Utf8Test}, but with index on simpleString.
+ */
+public class Utf8HashIndexTest extends Utf8Test {
+
+    @Override
+    protected BoxStore createBoxStore() {
+        return createBoxStore(IndexType.HASH);
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8Test.java b/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8Test.java
new file mode 100644
index 00000000..44eebbc2
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8Test.java
@@ -0,0 +1,56 @@
+package io.objectbox;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * The Java VM does not recognize the four-byte format of standard UTF-8;
+ * it uses its own two-times-three-byte format instead. Test to ensure these
+ * supplementary characters (code points above U+FFFF) are properly supported.
+ */
+public class Utf8Test extends AbstractObjectBoxTest {
+
+    // U+1F600, U+1F601, U+1F602
+    private static final String TEST_STRING = "😀😃😂 Hello";
+
+    @Test
+    public void putGetAndQuery_works() {
+        // Java stores UTF-16 internally (2 chars per emoji)
+        assertEquals(3 * 2 + 6, TEST_STRING.length());
+
+        // Put
+        TestEntity put = putTestEntity(TEST_STRING, 1);
+        putTestEntity("🚀🚁🚄", 2); // U+1F680, U+1F681, U+1F684
+        putTestEntity("😀🚁🚄", 3); // U+1F600, U+1F681, U+1F684
+        assertEquals(3, getTestEntityBox().count());
+
+        // Get
+        TestEntity get = getTestEntityBox().get(put.getId());
+        assertEquals(TEST_STRING, get.getSimpleString());
+
+        // Query String with equals
+        List<TestEntity> results = getTestEntityBox().query(
+                TestEntity_.simpleString.equal(TEST_STRING)
+        ).build().find();
+        assertEquals(1, results.size());
+        assertEquals(TEST_STRING, results.get(0).getSimpleString());
+
+        // Query String with starts with
+        List<TestEntity> resultsStartsWith = getTestEntityBox().query(
+                TestEntity_.simpleString.startsWith("😀") // U+1F600
+        ).build().find();
+        assertEquals(2, resultsStartsWith.size());
+        assertEquals(1, resultsStartsWith.get(0).getSimpleInt());
+        assertEquals(3, resultsStartsWith.get(1).getSimpleInt());
+
+        // Query String array
+        List<TestEntity> resultsArray = getTestEntityBox().query(
+                TestEntity_.simpleStringArray.containsElement(TEST_STRING)
+        ).build().find();
+        assertEquals(1, resultsArray.size());
+        assertEquals(TEST_STRING, resultsArray.get(0).getSimpleString());
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8ValueIndexTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8ValueIndexTest.java
new file mode 100644
index 00000000..aa215bc1
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/Utf8ValueIndexTest.java
@@ -0,0 +1,15 @@
+package io.objectbox;
+
+import io.objectbox.annotation.IndexType;
+
+/**
+ * Same as {@link Utf8Test}, but with index on simpleString.
+ */
+public class Utf8ValueIndexTest extends Utf8Test {
+
+    @Override
+    protected BoxStore createBoxStore() {
+        return createBoxStore(IndexType.VALUE);
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java
new file mode 100644
index 00000000..72c07db2
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexMapConverterTest.java
@@ -0,0 +1,287 @@
+/*
+ * Copyright 2020-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import org.junit.Test;
+
+import java.time.Instant;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests {@link FlexObjectConverter} and subclasses with flexible maps.
+ * For basic tests see {@link FlexObjectConverterTest}.
+ */
+public class FlexMapConverterTest {
+
+    @Test
+    public void keysString_valsSupportedTypes_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, Object> map = new HashMap<>();
+
+        convertAndBackThenAssert(null, converter);
+
+        convertAndBackThenAssert(map, converter);
+
+        map.put("string", "Grüezi");
+        map.put("boolean", true);
+        map.put("byte", (byte) 1);
+        map.put("short", (short) 1);
+        map.put("int", 1);
+        map.put("long", 1L);
+        map.put("float", 1.3f);
+        map.put("double", -1.4d);
+        map.put("null", null);
+        Map<String, Object> restoredMap = convertAndBack(map, converter);
+        // Java integers are returned as Long if one value is larger than 32 bits, so expect Long.
+        map.put("byte", 1L);
+        map.put("short", 1L);
+        map.put("int", 1L);
+        // Java float is returned as double, so expect double.
+        map.put("float", (double) 1.3f);
+        assertEquals(map, restoredMap);
+    }
+
+    /**
+     * If no item is wider than 32 bits, all integers are restored as Integer.
+     */
+    @Test
+    public void keysString_valsIntegersBiggest32Bit_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, Object> expected = new HashMap<>();
+
+        expected.put("integer-8bit", -1);
+        expected.put("integer-32bit", Integer.MAX_VALUE);
+        expected.put("long-8bit", -2L);
+        expected.put("long-32bit", (long) Integer.MIN_VALUE);
+
+        Map<String, Object> actual = convertAndBack(expected, converter);
+        
+        assertEquals(expected.size(), actual.size());
+        for (Object value : actual.values()) {
+            assertTrue(value instanceof Integer);
+        }
+    }
+
+    /**
+     * Using Long value converter, even if no item is wider than 32 bits, all integers are restored as Long.
+     */
+    @Test
+    public void keysString_valsLongBiggest32Bit_works() {
+        FlexObjectConverter converter = new StringLongMapConverter();
+        Map<String, Long> expected = new HashMap<>();
+
+        expected.put("long-8bit-neg", -1L);
+        expected.put("long-8bit", 2L);
+        expected.put("long-32bit-neg", (long) Integer.MIN_VALUE);
+        expected.put("long-32bit", (long) Integer.MAX_VALUE);
+
+        convertAndBackThenAssert(expected, converter);
+    }
+
+    /**
+     * If at least one item is 64 bit wide, all integers are restored as Long.
+     */
+    @Test
+    public void keysString_valsIntegersBiggest64Bit_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, Object> expected = new HashMap<>();
+
+        expected.put("integer-8bit", -1);
+        expected.put("integer-32bit", Integer.MAX_VALUE);
+        expected.put("long-64bit", Integer.MAX_VALUE + 1L);
+
+        Map<String, Object> actual = convertAndBack(expected, converter);
+
+        assertEquals(expected.size(), actual.size());
+        for (Object value : actual.values()) {
+            assertTrue(value instanceof Long);
+        }
+    }
+
+    // Note: can't use assertEquals(map, map) as byte[] does not implement equals(obj).
+    @Test
+    public void keysString_valsByteArray_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, byte[]> map = new HashMap<>();
+
+        map.put("bytearr", new byte[]{1, 2, 3});
+        Map<String, byte[]> actual = convertAndBack(map, converter);
+
+        assertEquals(map.size(), actual.size());
+        assertArrayEquals(map.get("bytearr"), actual.get("bytearr"));
+    }
+
+    @Test
+    public void keysInteger_works() {
+        FlexObjectConverter converter = new IntegerFlexMapConverter();
+        Map<Integer, String> map = new HashMap<>();
+
+        convertAndBackThenAssert(null, converter);
+
+        convertAndBackThenAssert(map, converter);
+
+        map.put(-1, "Grüezi");
+        map.put(1, "Idea");
+        convertAndBackThenAssert(map, converter);
+    }
+
+    @Test
+    public void keysLong_works() {
+        FlexObjectConverter converter = new LongFlexMapConverter();
+        Map<Long, String> map = new HashMap<>();
+
+        convertAndBackThenAssert(null, converter);
+
+        convertAndBackThenAssert(map, converter);
+
+        map.put(-1L, "Grüezi");
+        map.put(1L, "Idea");
+        convertAndBackThenAssert(map, converter);
+    }
+
+    @Test
+    public void nestedMap_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        // Restriction: map keys must all have same type.
+        Map<String, Map<String, String>> map = new HashMap<>();
+
+        convertAndBackThenAssert(null, converter);
+
+        convertAndBackThenAssert(map, converter);
+
+        Map<String, String> embeddedMap1 = new HashMap<>();
+        embeddedMap1.put("Hello1", "Grüezi1");
+        embeddedMap1.put("💡1", "Idea1");
+        embeddedMap1.put("null1", null);
+        map.put("Hello", embeddedMap1);
+        Map<String, String> embeddedMap2 = new HashMap<>();
+        embeddedMap2.put("Hello2", "Grüezi2");
+        embeddedMap2.put("💡2", "Idea2");
+        embeddedMap2.put("null2", null);
+        map.put("💡", embeddedMap2);
+        convertAndBackThenAssert(map, converter);
+    }
+
+    @Test
+    public void nestedList_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, List<Object>> map = new HashMap<>();
+
+        convertAndBackThenAssert(null, converter);
+
+        convertAndBackThenAssert(map, converter);
+
+        List<Object> embeddedList1 = new LinkedList<>();
+        embeddedList1.add("Grüezi");
+        embeddedList1.add(true);
+        embeddedList1.add(-2L);
+        embeddedList1.add(1.3f);
+        embeddedList1.add(-1.4d);
+        embeddedList1.add(null);
+        map.put("Hello", embeddedList1);
+        List<Object> embeddedList2 = new LinkedList<>();
+        embeddedList2.add("Grüezi");
+        embeddedList2.add(true);
+        embeddedList2.add(-22L);
+        embeddedList2.add(2.3f);
+        embeddedList2.add(-2.4d);
+        map.put("💡", embeddedList2);
+        Map<String, List<Object>> restoredMap = convertAndBack(map, converter);
+        // Java float is returned as double, so expect double.
+        embeddedList1.set(3, (double) 1.3f);
+        embeddedList2.set(3, (double) 2.3f);
+        assertEquals(map, restoredMap);
+    }
+
+    // Note: can't use assertEquals(map, map) as byte[] does not implement equals(obj).
+    @Test
+    public void nestedListByteArray_works() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, List<byte[]>> map = new HashMap<>();
+
+        List<byte[]> embeddedList = new LinkedList<>();
+        embeddedList.add(new byte[]{1, 2, 3});
+        map.put("list", embeddedList);
+        Map<String, List<byte[]>> actual = convertAndBack(map, converter);
+
+        assertEquals(map.size(), actual.size());
+        assertEquals(map.get("list").size(), actual.get("list").size());
+        assertArrayEquals(map.get("list").get(0), actual.get("list").get(0));
+    }
+
+    @Test
+    public void nullKey_throws() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, String> map = new HashMap<>();
+
+        map.put(null, "Idea");
+        convertThenAssertThrows(map, converter, "Map keys must not be null");
+    }
+
+    @Test
+    public void unsupportedKey_throws() {
+        Map<Object, Object> map = new HashMap<>();
+        map.put(false, "supported");
+
+        convertThenAssertThrows(map, new FlexObjectConverter(), "Map keys must be String");
+        convertThenAssertThrows(map, new StringLongMapConverter(), "Map keys must be String");
+        convertThenAssertThrows(map, new IntegerFlexMapConverter(), "Map keys must be Integer");
+        convertThenAssertThrows(map, new IntegerLongMapConverter(), "Map keys must be Integer");
+        convertThenAssertThrows(map, new LongFlexMapConverter(), "Map keys must be Long");
+        convertThenAssertThrows(map, new LongLongMapConverter(), "Map keys must be Long");
+    }
+
+    @Test
+    public void unsupportedValue_throws() {
+        FlexObjectConverter converter = new StringFlexMapConverter();
+        Map<String, Object> map = new HashMap<>();
+
+        map.put("Hello", Instant.now());
+        convertThenAssertThrows(map, converter, "Map values of this type are not supported: Instant");
+    }
+
+    @SuppressWarnings("unchecked")
+    private <K, V> Map<K, V> convertAndBack(@Nullable Map<K, V> expected, FlexObjectConverter converter) {
+        byte[] converted = converter.convertToDatabaseValue(expected);
+
+        return (Map<K, V>) converter.convertToEntityProperty(converted);
+    }
+
+    private <K, V> void convertAndBackThenAssert(@Nullable Map<K, V> expected, FlexObjectConverter converter) {
+        assertEquals(expected, convertAndBack(expected, converter));
+    }
+
+    @SuppressWarnings({"rawtypes"})
+    private void convertThenAssertThrows(Map map, FlexObjectConverter converter, String expectedMessage) {
+        IllegalArgumentException exception = assertThrows(
+                IllegalArgumentException.class,
+                () -> converter.convertToDatabaseValue(map)
+        );
+        assertEquals(expectedMessage, exception.getMessage());
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java
new file mode 100644
index 00000000..56f7c73e
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/FlexObjectConverterTest.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright 2021-2024 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.converter;
+
+import org.junit.Test;
+
+import java.util.LinkedList;
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests {@link FlexObjectConverter} basic types and flexible list conversion.
+ * Flexible maps conversion is tested by {@link FlexMapConverterTest}.
+ */
+public class FlexObjectConverterTest {
+
+    @Test
+    public void supportedBasicTypes_works() {
+        FlexObjectConverter converter = new FlexObjectConverter();
+
+        convertAndBackThenAssert(null, converter);
+
+        convertAndBackThenAssert("Grüezi", converter);
+        convertAndBackThenAssert(true, converter);
+        // Java integers are returned as Integer if no value is larger than 32 bits, so expect Integer.
+        Object restoredByte = convertAndBack((byte) 1, converter);
+        assertEquals(1, restoredByte);
+        Object restoredShort = convertAndBack((short) 1, converter);
+        assertEquals(1, restoredShort);
+        Object restoredInteger = convertAndBack(1, converter);
+        assertEquals(1, restoredInteger);
+        Object restoredLong = convertAndBack(1L, converter);
+        assertEquals(1, restoredLong);
+        // Java Float is returned as Double, so expect Double.
+        Object restoredFloat = convertAndBack(1.3f, converter);
+        assertEquals((double) 1.3f, restoredFloat);
+        convertAndBackThenAssert(1.4d, converter);
+    }
+
+    @Test
+    public void list_works() {
+        FlexObjectConverter converter = new FlexObjectConverter();
+        List<Object> list = new LinkedList<>();
+
+        // empty list
+        convertAndBackThenAssert(list, converter);
+
+        // list with supported types
+        list.add("Grüezi");
+        list.add(true);
+        list.add((byte) 1);
+        list.add((short) 1);
+        list.add(1);
+        list.add(-2L);
+        list.add(1.3f);
+        list.add(-1.4d);
+        list.add(null);
+        List<Object> restoredList = convertAndBack(list, converter);
+        // Java integers are returned as Long as one element is larger than 32 bits, so expect Long.
+        list.set(2, 1L);
+        list.set(3, 1L);
+        list.set(4, 1L);
+        // Java Float is returned as Double, so expect Double.
+        list.set(6, (double) 1.3f);
+        assertEquals(list, restoredList);
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T convertAndBack(@Nullable T expected, FlexObjectConverter converter) {
+        byte[] converted = converter.convertToDatabaseValue(expected);
+
+        return (T) converter.convertToEntityProperty(converted);
+    }
+
+    private <T> void convertAndBackThenAssert(@Nullable T expected, FlexObjectConverter converter) {
+        assertEquals(expected, convertAndBack(expected, converter));
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/converter/StringMapConverterTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/StringMapConverterTest.java
new file mode 100644
index 00000000..e429d536
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/converter/StringMapConverterTest.java
@@ -0,0 +1,35 @@
+package io.objectbox.converter;
+
+import org.junit.Test;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import javax.annotation.Nullable;
+
+
+import static org.junit.Assert.assertEquals;
+
+public class StringMapConverterTest {
+
+    @Test
+    public void works() {
+        convertAndBackThenAssert(null);
+
+        convertAndBackThenAssert(new HashMap<>());
+
+        Map<String, String> mapWithValues = new HashMap<>();
+        mapWithValues.put("Hello", "Grüezi");
+        mapWithValues.put("💡", "Idea");
+        mapWithValues.put("", "Empty String Key");
+        convertAndBackThenAssert(mapWithValues);
+    }
+
+    private void convertAndBackThenAssert(@Nullable Map<String, String> expected) {
+        StringMapConverter converter = new StringMapConverter();
+        byte[] converted = converter.convertToDatabaseValue(expected);
+
+        Map<String, String> actual = converter.convertToEntityProperty(converted);
+        assertEquals(expected, actual);
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java
new file mode 100644
index 00000000..d3cb1a77
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/exception/ExceptionTest.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright 2020 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.exception;
+
+import org.junit.Test;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import io.objectbox.AbstractObjectBoxTest;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Tests related to {@link DbExceptionListener}.
+ *
+ * Note: this test has an equivalent in test-java-android integration tests.
+ */
+public class ExceptionTest extends AbstractObjectBoxTest {
+
+    @Test
+    public void exceptionListener_null_works() {
+        store.setDbExceptionListener(null);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void exceptionListener_closedStore_throws() {
+        store.close();
+        store.setDbExceptionListener(e -> System.out.println("This is never called"));
+    }
+
+    private static final AtomicInteger weakRefListenerCalled = new AtomicInteger(0);
+
+    @Test
+    public void exceptionListener_noLocalRef_works() throws InterruptedException {
+        weakRefListenerCalled.set(0);
+        // Note: do not use lambda, it would keep a reference to this class
+        // and prevent garbage collection of the listener.
+        //noinspection Convert2Lambda
+        DbExceptionListener listenerNoRef = new DbExceptionListener() {
+            @Override
+            public void onDbException(Exception e) {
+                System.out.println("Listener without strong reference is called");
+                weakRefListenerCalled.incrementAndGet();
+            }
+        };
+        WeakReference<DbExceptionListener> weakReference = new WeakReference<>(listenerNoRef);
+
+        // Set and clear local reference.
+        store.setDbExceptionListener(listenerNoRef);
+        //noinspection UnusedAssignment
+        listenerNoRef = null;
+
+        // Ensure weak reference is kept as JNI is holding on to listener using a "global ref".
+        int triesClearWeakRef = 5;
+        while (weakReference.get() != null) {
+            if (--triesClearWeakRef == 0) break;
+            System.out.println("Suggesting GC");
+            System.gc();
+            System.runFinalization();
+            //noinspection BusyWait
+            Thread.sleep(300);
+        }
+        assertEquals("Failed to keep weak reference to listener", 0, triesClearWeakRef);
+        assertNotNull(weakReference.get());
+
+        // Throw, listener should be called.
+        assertThrows(
+                DbException.class,
+                () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
+        );
+        assertEquals(1, weakRefListenerCalled.get());
+
+        // Remove reference from native side.
+        store.setDbExceptionListener(null);
+
+        // Try and succeed to release weak reference.
+        triesClearWeakRef = 5;
+        while (weakReference.get() != null) {
+            if (--triesClearWeakRef == 0) break;
+            System.out.println("Suggesting GC");
+            System.gc();
+            System.runFinalization();
+            //noinspection BusyWait
+            Thread.sleep(300);
+        }
+        assertTrue("Failed to release weak reference to listener", triesClearWeakRef > 0);
+
+        // Throw, listener should not be called.
+        assertThrows(
+                DbException.class,
+                () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
+        );
+        assertEquals(1, weakRefListenerCalled.get());
+    }
+
+    @Test
+    public void exceptionListener_noref() throws InterruptedException {
+        weakRefListenerCalled.set(0);
+
+        //noinspection Convert2Lambda
+        store.setDbExceptionListener(new DbExceptionListener() {
+            @Override
+            public void onDbException(Exception e) {
+                System.out.println("Listener without reference is called");
+                weakRefListenerCalled.incrementAndGet();
+            }
+        });
+
+        for (int i = 0; i < 5; i++) {
+            System.gc();
+            System.runFinalization();
+            Thread.sleep(100);
+        }
+
+        // Throw, listener should be called.
+        assertThrows(
+                DbException.class,
+                () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
+        );
+        assertEquals(1, weakRefListenerCalled.get());
+    }
+
+    @Test
+    public void exceptionListener_removing_works() {
+        AtomicBoolean replacedListenerCalled = new AtomicBoolean(false);
+        DbExceptionListener listenerRemoved = e -> replacedListenerCalled.set(true);
+
+        store.setDbExceptionListener(listenerRemoved);
+        store.setDbExceptionListener(null);
+
+        assertThrows(
+                DbException.class,
+                () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
+        );
+        assertFalse("Should not have called removed DbExceptionListener.", replacedListenerCalled.get());
+    }
+
+    @Test
+    public void exceptionListener_replacing_works() {
+        AtomicBoolean replacedListenerCalled = new AtomicBoolean(false);
+        DbExceptionListener listenerReplaced = e -> replacedListenerCalled.set(true);
+
+        AtomicBoolean newListenerCalled = new AtomicBoolean(false);
+        DbExceptionListener listenerNew = e -> newListenerCalled.set(true);
+
+        store.setDbExceptionListener(listenerReplaced);
+        store.setDbExceptionListener(listenerNew);
+
+        assertThrows(
+                DbException.class,
+                () -> DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), 0)
+        );
+        assertFalse("Should not have called replaced DbExceptionListener.", replacedListenerCalled.get());
+        assertTrue("Failed to call new DbExceptionListener.", newListenerCalled.get());
+    }
+
+    @Test
+    public void testThrowExceptions() {
+        final List<Exception> exs = new ArrayList<>();
+        DbExceptionListener exceptionListener = e -> {
+            exs.add(e);
+            DbExceptionListener.cancelCurrentException();
+        };
+        store.setDbExceptionListener(exceptionListener);
+        int maxExNo = 10;
+        for (int exNo = 0; exNo <= maxExNo; exNo++) {
+            DbExceptionListenerJni.nativeThrowException(store.getNativeStore(), exNo);
+        }
+        int expectedSize = maxExNo + 1;
+        assertEquals(expectedSize, exs.size());
+        Class<?>[] expectedClasses = {
+                DbException.class,
+                IllegalStateException.class,
+                DbException.class,  // OpenDb
+                DbFullException.class,
+                DbShutdownException.class,
+                DbSchemaException.class,
+                ConstraintViolationException.class,
+                UniqueViolationException.class,
+                FileCorruptException.class,
+                PagesCorruptException.class,
+                IllegalArgumentException.class,
+        };
+        assertEquals(expectedSize, expectedClasses.length);
+        for (int i = 0; i < expectedSize; i++) {
+            assertEquals(expectedClasses[i], exs.get(i).getClass());
+        }
+    }
+
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java
index 21cf1f31..0a43a1d4 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/index/IndexReaderRenewTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java
index 518c6ad7..877d5aea 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/AbstractQueryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 ObjectBox Ltd. All rights reserved.
+ * Copyright 2018-2025 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,18 +16,28 @@
 
 package io.objectbox.query;
 
-import io.objectbox.*;
 import org.junit.Before;
 
 import java.util.ArrayList;
 import java.util.List;
 
+import javax.annotation.Nullable;
+
+import io.objectbox.AbstractObjectBoxTest;
+import io.objectbox.Box;
+import io.objectbox.BoxStoreBuilder;
+import io.objectbox.TestEntity;
+import io.objectbox.annotation.IndexType;
+import io.objectbox.config.DebugFlags;
+
 public class AbstractQueryTest extends AbstractObjectBoxTest {
     protected Box<TestEntity> box;
 
     @Override
-    protected BoxStoreBuilder createBoxStoreBuilder(boolean withIndex) {
-        return super.createBoxStoreBuilder(withIndex).debugFlags(DebugFlags.LOG_QUERY_PARAMETERS);
+    protected BoxStoreBuilder createBoxStoreBuilder(@Nullable IndexType simpleStringIndexType) {
+        BoxStoreBuilder builder = super.createBoxStoreBuilder(simpleStringIndexType);
+        if (DEBUG_LOG) builder.debugFlags(DebugFlags.LOG_QUERY_PARAMETERS);
+        return builder;
     }
 
     @Before
@@ -37,11 +47,33 @@ public void setUpBox() {
 
     /**
      * Puts 10 TestEntity starting at nr 2000 using {@link AbstractObjectBoxTest#createTestEntity(String, int)}.
+     * <li>simpleInt = [2000..2009]</li>
+     * <li>simpleByte = [2010..2019]</li>
+     * <li>simpleBoolean = [true, false, ..., false]</li>
+     * <li>simpleShort = [2100..2109]</li>
+     * <li>simpleLong = [3000..3009]</li>
+     * <li>simpleFloat = [400.0..400.9]</li>
+     * <li>simpleDouble = [2020.00..2020.09] (approximately)</li>
+     * <li>simpleByteArray = [{1,2,2000}..{1,2,2009}]</li>
+     * <li>boolArray = [{true, false, true}..{false, false, true}]</li>
+     * <li>shortArray = [{-2100,2100}..{-2109,2109}]</li>
+     * <li>intArray = [{-2000,2000}..{-2009,2009}]</li>
+     * <li>longArray = [{-3000,3000}..{-3009,3009}]</li>
+     * <li>floatArray = [{-400.0,400.0}..{-400.9,400.9}]</li>
+     * <li>doubleArray = [{-2020.00,2020.00}..{-2020.09,2020.09}] (approximately)</li>
+     * <li>date = [Date(3000)..Date(3009)]</li>
      */
-    List<TestEntity> putTestEntitiesScalars() {
+    public List<TestEntity> putTestEntitiesScalars() {
         return putTestEntities(10, null, 2000);
     }
 
+    /**
+     * Puts 5 TestEntity starting at nr 1 using {@link AbstractObjectBoxTest#createTestEntity(String, int)}.
+     * <li>simpleString = banana, apple, bar, banana milk shake, foo bar</li>
+     * <li>simpleStringArray = [simpleString]</li>
+     * <li>simpleStringList = [simpleString]</li>
+     * <li>charArray = simpleString.toCharArray()</li>
+     */
     List<TestEntity> putTestEntitiesStrings() {
         List<TestEntity> entities = new ArrayList<>();
         entities.add(createTestEntity("banana", 1));
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java
new file mode 100644
index 00000000..af97295d
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/FlexQueryTest.java
@@ -0,0 +1,289 @@
+/*
+ * Copyright 2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.TestEntity;
+import io.objectbox.TestEntity_;
+import org.junit.Test;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static io.objectbox.TestEntity_.stringObjectMap;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+public class FlexQueryTest extends AbstractQueryTest {
+
+    private TestEntity createFlexPropertyEntity(@Nullable Object flex) {
+        TestEntity entity = new TestEntity();
+        entity.setFlexProperty(flex);
+        return entity;
+    }
+
+    /**
+     * equals works for flexible string and integer properties.
+     */
+    @Test
+    public void equals_flexString() {
+        box.put(
+                createFlexPropertyEntity("banana"),
+                createFlexPropertyEntity(-1),
+                createFlexPropertyEntity(1.3f),
+                createFlexPropertyEntity(-1.4d),
+                createFlexPropertyEntity(null)
+        );
+
+        assertFlexPropertyEqualsMatch("banana");
+        assertFlexPropertyEqualsMatch(-1);
+
+        // Check isNull as well
+        List<TestEntity> results = box.query(TestEntity_.flexProperty.isNull()).build().find();
+        assertEquals(1, results.size());
+        assertNull(results.get(0).getFlexProperty());
+    }
+
+    private void assertFlexPropertyEqualsMatch(Object value) {
+        List<TestEntity> results = box.query(TestEntity_.flexProperty.equal(value.toString())).build().find();
+        assertEquals(1, results.size());
+        assertEquals(value, results.get(0).getFlexProperty());
+    }
+
+    /**
+     * containsElement matches strings and integers of flexible list.
+     */
+    @Test
+    public void containsElement_flexList() {
+        List<Object> flexListMatch = new ArrayList<>();
+        flexListMatch.add("banana");
+        flexListMatch.add(12);
+        List<Object> flexListNoMatch = new ArrayList<>();
+        flexListNoMatch.add("banana milk shake");
+        flexListNoMatch.add(1234);
+        List<Object> flexListNotSupported = new ArrayList<>();
+        flexListNotSupported.add(1.3f);
+        flexListNotSupported.add(-1.4d);
+        box.put(
+                createFlexPropertyEntity(flexListMatch),
+                createFlexPropertyEntity(flexListNoMatch),
+                createFlexPropertyEntity(flexListNotSupported),
+                createFlexPropertyEntity(null)
+        );
+
+        assertFlexListContainsElement("banana");
+        assertFlexListContainsElement(12);
+    }
+
+    @SuppressWarnings("unchecked")
+    private void assertFlexListContainsElement(Object value) {
+        List<TestEntity> results = box.query(TestEntity_.flexProperty.containsElement(value.toString())).build().find();
+        assertEquals(1, results.size());
+        List<Object> list = (List<Object>) results.get(0).getFlexProperty();
+        assertNotNull(list);
+        assertTrue(list.contains("banana"));
+    }
+
+    private TestEntity createFlexMapEntity(String s, boolean b, long l, float f, double d) {
+        TestEntity entity = new TestEntity();
+        Map<String, Object> map = new HashMap<>();
+        map.put(s + "-string", s);
+        map.put(s + "-boolean", b);
+        map.put(s + "-long", l);
+        map.put(s + "-float", f);
+        map.put(s + "-double", d);
+        map.put(s + "-list", Arrays.asList(s, b, l, f, d));
+        Map<String, Object> embeddedMap = new HashMap<>();
+        embeddedMap.put("embedded-key", "embedded-value");
+        map.put(s + "-map", embeddedMap);
+        entity.setStringObjectMap(map);
+        return entity;
+    }
+
+    @Test
+    public void contains_stringObjectMap() {
+        // Note: map keys and values can not be null, so no need to test. See FlexMapConverterTest.
+        box.put(
+                createFlexMapEntity("banana", true, -1L, 1.3f, -1.4d),
+                createFlexMapEntity("banana milk shake", false, 1L, -1.3f, 1.4d)
+        );
+
+        // contains throws when used with flex property.
+        IllegalArgumentException exception = assertThrows(IllegalArgumentException.class,
+                () -> box.query(stringObjectMap.contains("banana-string")));
+        assertEquals("Property type is neither a string nor array of strings: Flex", exception.getMessage());
+
+        // containsElement only matches if key is equal.
+        assertContainsKey("banana-string");
+        assertContainsKey("banana-boolean");
+        assertContainsKey("banana-long");
+        assertContainsKey("banana-float");
+        assertContainsKey("banana-double");
+        assertContainsKey("banana-list");
+        assertContainsKey("banana-map");
+
+        // containsKeyValue only matches if key and value is equal.
+        assertQueryCondition(stringObjectMap.equalKeyValue("banana-string", "banana", QueryBuilder.StringOrder.CASE_SENSITIVE), 1);
+        assertQueryCondition(stringObjectMap.equalKeyValue("banana-long", -1L), 1);
+
+        // setParameters works with strings and integers.
+        Query<TestEntity> setParamQuery = box.query(
+                stringObjectMap.equalKeyValue("", "", QueryBuilder.StringOrder.CASE_SENSITIVE).alias("contains")
+        ).build();
+        assertEquals(0, setParamQuery.find().size());
+
+        setParamQuery.setParameters(stringObjectMap, "banana-string", "banana");
+        List<TestEntity> setParamResults = setParamQuery.find();
+        assertEquals(1, setParamResults.size());
+        assertTrue(setParamResults.get(0).getStringObjectMap().containsKey("banana-string"));
+
+        setParamQuery.setParameters("contains", "banana milk shake-string", "banana milk shake");
+        setParamResults = setParamQuery.find();
+        assertEquals(1, setParamResults.size());
+        assertTrue(setParamResults.get(0).getStringObjectMap().containsKey("banana milk shake-string"));
+
+        setParamQuery.close();
+    }
+
+    private void assertContainsKey(String key) {
+        try (Query<TestEntity> query = box.query(
+                stringObjectMap.containsElement(key)
+        ).build()) {
+            List<TestEntity> results = query.find();
+            assertEquals(1, results.size());
+            assertTrue(results.get(0).getStringObjectMap().containsKey(key));
+        }
+    }
+
+    private TestEntity createObjectWithStringObjectMap(String s, long l, double d) {
+        TestEntity entity = new TestEntity();
+        Map<String, Object> map = new HashMap<>();
+        map.put("key-string", s);
+        map.put("key-long", l);
+        map.put("key-double", d);
+        entity.setStringObjectMap(map);
+        return entity;
+    }
+
+    private List<TestEntity> createObjectsWithStringObjectMap() {
+        return Arrays.asList(
+                createObjectWithStringObjectMap("apple", -1L, -0.2d),
+                createObjectWithStringObjectMap("Cherry", 3L, -1234.56d),
+                createObjectWithStringObjectMap("Apple", 234234234L, 1234.56d),
+                createObjectWithStringObjectMap("pineapple", -567L, 0.1d)
+        );
+    }
+
+    @Test
+    public void greaterKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), apple, pineapple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), pineapple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-long", -2L), apple, Cherry, Apple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-long", 234234234L));
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-double", 0.0d), Apple, pineapple);
+        assertQueryCondition(stringObjectMap.greaterKeyValue("key-double", 1234.56d));
+    }
+
+    @Test
+    public void greaterEqualsKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), apple, Cherry, pineapple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), Cherry, pineapple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-long", -2L), apple, Cherry, Apple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-long", 234234234L), Apple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-double", 0.05d), Apple, pineapple);
+        assertQueryCondition(stringObjectMap.greaterOrEqualKeyValue("key-double", 1234.54d), Apple);
+    }
+
+    @Test
+    public void lessKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), Apple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), apple, Apple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-long", -2L), pineapple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-long", 6734234234L), apple, Cherry, Apple, pineapple);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-double", 0.0d), apple, Cherry);
+        assertQueryCondition(stringObjectMap.lessKeyValue("key-double", 1234.56d), apple, Cherry, pineapple);
+    }
+
+    @Test
+    public void lessEqualsKeyValue_stringObjectMap() {
+        List<TestEntity> objects = createObjectsWithStringObjectMap();
+        box.put(objects);
+        long apple = objects.get(0).getId();
+        long Cherry = objects.get(1).getId();
+        long Apple = objects.get(2).getId();
+        long pineapple = objects.get(3).getId();
+
+        // Note: CASE_SENSITIVE orders like "Apple, Cherry, apple, pineapple"
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_SENSITIVE), Cherry, Apple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-string", "Cherry",
+                QueryBuilder.StringOrder.CASE_INSENSITIVE), apple, Cherry, Apple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-long", -1L), apple, pineapple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-long", -567L), pineapple);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-double", 0.0d), apple, Cherry);
+        assertQueryCondition(stringObjectMap.lessOrEqualKeyValue("key-double", 1234.56d), apple, Cherry, Apple, pineapple);
+    }
+
+    private void assertQueryCondition(PropertyQueryCondition<TestEntity> condition, long... expectedIds) {
+        try (Query<TestEntity> query = box.query(condition).build()) {
+            List<TestEntity> results = query.find();
+            assertResultIds(expectedIds, results);
+        }
+    }
+
+    private void assertResultIds(long[] expected, List<TestEntity> results) {
+        assertArrayEquals(expected, results.stream().mapToLong(TestEntity::getId).toArray());
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java
index 4e8b9078..14956362 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/LazyListTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -176,6 +176,29 @@ public void testUncached() {
         }
     }
 
+    @Test
+    public void listIterator_indexOutOfBounds_throws() {
+        putTestEntities(3);
+        LazyList<TestEntity> listLazy = getTestEntityBox().query().build().findLazyCached();
+        int size = listLazy.size();
+
+        try {
+            listLazy.listIterator(-1);
+            fail("listIterator should throw for negative index");
+        } catch (IndexOutOfBoundsException expected) {
+            // Expected, OK
+        }
+
+        try {
+            listLazy.listIterator(size + 1);
+            fail("listIterator should throw for index larger than size");
+        } catch (IndexOutOfBoundsException expected) {
+            // Expected, OK
+        }
+
+        assertNotNull(listLazy.listIterator(size));
+    }
+
 
     protected void assertIds(List<TestEntity> list, List<TestEntity> list2) {
         for (int i = 0; i < list.size(); i++) {
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java
index 23baf22d..6e6ca2f1 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/PropertyQueryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,6 +26,7 @@
 import io.objectbox.exception.DbException;
 import io.objectbox.exception.NumericOverflowException;
 import io.objectbox.query.QueryBuilder.StringOrder;
+import org.junit.function.ThrowingRunnable;
 
 
 import static io.objectbox.TestEntity_.simpleBoolean;
@@ -76,13 +77,50 @@ private void putTestEntityFloat(float vFloat, double vDouble) {
         box.put(entity);
     }
 
+    @Test
+    public void useAfterClose_fails() {
+        Query<TestEntity> query = box.query().build();
+        query.close();
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findStrings());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findLongs());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findInts());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findShorts());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findChars());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findBytes());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findFloats());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findDoubles());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findString());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findLong());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findInt());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findShort());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findChar());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findByte());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findBoolean());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findFloat());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).findDouble());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).sum());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).sumDouble());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).max());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).maxDouble());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).min());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).minDouble());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).avg());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).avgLong());
+        assertThrowsQueryIsClosed(() -> query.property(simpleInt).count());
+    }
+
+    private void assertThrowsQueryIsClosed(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("This query is closed. Build and use a new one.", ex.getMessage());
+    }
+
     @Test
     public void testFindStrings() {
         putTestEntity(null, 1000);
         putTestEntity("BAR", 100);
         putTestEntitiesStrings();
         putTestEntity("banana", 101);
-        Query<TestEntity> query = box.query().startsWith(simpleString, "b").build();
+        Query<TestEntity> query = box.query().startsWith(simpleString, "b", StringOrder.CASE_INSENSITIVE).build();
 
         String[] result = query.property(simpleString).findStrings();
         assertEquals(5, result.length);
@@ -727,9 +765,9 @@ public void avgLong_negativeOverflow() {
         putTestEntityInteger((byte) 0, (short) 0, 0, -1);
 
         Query<TestEntity> baseQuery = box.query().build();
-        assertEquals(Long.MIN_VALUE / 2, baseQuery.property(simpleLong).avgLong());
+        assertEquals(Long.MIN_VALUE / 2 - 1, baseQuery.property(simpleLong).avgLong());
         // Should not change if treated as unsigned.
-        assertEquals(Long.MIN_VALUE / 2, baseQuery.property(simpleLongU).avgLong());
+        assertEquals(Long.MIN_VALUE / 2 - 1, baseQuery.property(simpleLongU).avgLong());
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java
new file mode 100644
index 00000000..f6859d26
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryCopyTest.java
@@ -0,0 +1,116 @@
+package io.objectbox.query;
+
+import io.objectbox.TestEntity;
+import io.objectbox.TestEntity_;
+import org.junit.Test;
+
+import java.util.Comparator;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.Assert.*;
+
+public class QueryCopyTest extends AbstractQueryTest {
+
+    @Test
+    public void queryCopy_isClone() {
+        putTestEntity("orange", 1);
+        TestEntity banana = putTestEntity("banana", 2);
+        putTestEntity("apple", 3);
+        TestEntity bananaMilkShake = putTestEntity("banana milk shake", 4);
+        putTestEntity("pineapple", 5);
+        putTestEntity("papaya", 6);
+
+        // Only even nr: 2, 4, 6.
+        QueryFilter<TestEntity> filter = entity -> entity.getSimpleInt() % 2 == 0;
+        // Reverse insert order: 6, 4, 2.
+        Comparator<TestEntity> comparator = Comparator.comparingLong(testEntity -> -testEntity.getId());
+
+        Query<TestEntity> queryOriginal = box.query(TestEntity_.simpleString.contains("").alias("fruit"))
+                .filter(filter)
+                .sort(comparator)
+                .build();
+        // Only bananas: 4, 2.
+        queryOriginal.setParameter("fruit", banana.getSimpleString());
+
+        Query<TestEntity> queryCopy = queryOriginal.copy();
+
+        // Object instances and native query handle should differ.
+        assertNotEquals(queryOriginal, queryCopy);
+        assertNotEquals(queryOriginal.handle, queryCopy.handle);
+
+        // Verify results are identical.
+        List<TestEntity> resultsOriginal = queryOriginal.find();
+        queryOriginal.close();
+        List<TestEntity> resultsCopy = queryCopy.find();
+        queryCopy.close();
+        assertEquals(2, resultsOriginal.size());
+        assertEquals(2, resultsCopy.size());
+        assertTestEntityEquals(bananaMilkShake, resultsOriginal.get(0));
+        assertTestEntityEquals(bananaMilkShake, resultsCopy.get(0));
+        assertTestEntityEquals(banana, resultsOriginal.get(1));
+        assertTestEntityEquals(banana, resultsCopy.get(1));
+    }
+
+    @Test
+    public void queryCopy_setParameter_noEffectOriginal() {
+        TestEntity orange = putTestEntity("orange", 1);
+        TestEntity banana = putTestEntity("banana", 2);
+
+        Query<TestEntity> queryOriginal = box
+                .query(TestEntity_.simpleString.equal(orange.getSimpleString()).alias("fruit"))
+                .build();
+
+        // Set parameter on clone that changes result.
+        Query<TestEntity> queryCopy = queryOriginal.copy()
+                .setParameter("fruit", banana.getSimpleString());
+
+        List<TestEntity> resultsOriginal = queryOriginal.find();
+        queryOriginal.close();
+        assertEquals(1, resultsOriginal.size());
+        assertTestEntityEquals(orange, resultsOriginal.get(0));
+
+        List<TestEntity> resultsCopy = queryCopy.find();
+        queryCopy.close();
+        assertEquals(1, resultsCopy.size());
+        assertTestEntityEquals(banana, resultsCopy.get(0));
+    }
+
+    private void assertTestEntityEquals(TestEntity expected, TestEntity actual) {
+        assertEquals(expected.getId(), actual.getId());
+        assertEquals(expected.getSimpleString(), actual.getSimpleString());
+    }
+
+    @Test
+    public void queryThreadLocal() throws InterruptedException {
+        Query<TestEntity> queryOriginal = box.query().build();
+        QueryThreadLocal<TestEntity> threadLocal = new QueryThreadLocal<>(queryOriginal);
+
+        AtomicReference<Query<TestEntity>> queryThreadAtomic = new AtomicReference<>();
+        CountDownLatch latch = new CountDownLatch(1);
+        new Thread(() -> {
+            queryThreadAtomic.set(threadLocal.get());
+            latch.countDown();
+        }).start();
+
+        assertTrue(latch.await(1, TimeUnit.SECONDS));
+
+        Query<TestEntity> queryThread = queryThreadAtomic.get();
+        Query<TestEntity> queryMain = threadLocal.get();
+
+        // Assert that initialValue returns something.
+        assertNotNull(queryThread);
+        assertNotNull(queryMain);
+
+        // Assert that initialValue returns clones.
+        assertNotEquals(queryThread.handle, queryOriginal.handle);
+        assertNotEquals(queryMain.handle, queryOriginal.handle);
+        assertNotEquals(queryThread.handle, queryMain.handle);
+
+        queryOriginal.close();
+        queryMain.close();
+        queryThread.close();
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java
index 7e7d756f..79654d7c 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryObserverTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,50 +19,138 @@
 import org.junit.Before;
 import org.junit.Test;
 
-import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 import io.objectbox.AbstractObjectBoxTest;
 import io.objectbox.Box;
+import io.objectbox.ObjectClassObserverTest;
 import io.objectbox.TestEntity;
 import io.objectbox.reactive.DataObserver;
-import io.objectbox.reactive.DataTransformer;
+import io.objectbox.reactive.DataSubscription;
 
 
 import static io.objectbox.TestEntity_.simpleInt;
 import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
 
-public class QueryObserverTest extends AbstractObjectBoxTest implements DataObserver<List<TestEntity>> {
+public class QueryObserverTest extends AbstractObjectBoxTest {
 
     private Box<TestEntity> box;
-    private List<List<TestEntity>> receivedChanges = new CopyOnWriteArrayList<>();
-    private CountDownLatch latch = new CountDownLatch(1);
 
     @Before
     public void setUpBox() {
         box = getTestEntityBox();
     }
 
+    @Test
+    public void observer_removeDuringCallback_works() throws InterruptedException {
+        SelfRemovingObserver testObserver = new SelfRemovingObserver();
+        // Note: use onlyChanges to not trigger observer on subscribing.
+        testObserver.dataSubscription = box.query().build()
+                .subscribe()
+                .onlyChanges()
+                .observer(testObserver);
+
+        // Trigger event.
+        putTestEntitiesScalars();
+
+        // Should have gotten past dataSubscription.cancel() without crashing.
+        assertTrue(testObserver.latch.await(5, TimeUnit.SECONDS));
+
+        // Just to make sure: trigger another event, should not be received.
+        testObserver.latch = new CountDownLatch(1);
+        putTestEntitiesScalars();
+        assertFalse(testObserver.latch.await(5, TimeUnit.SECONDS));
+    }
+
+    private static class SelfRemovingObserver implements DataObserver<List<TestEntity>> {
+
+        CountDownLatch latch = new CountDownLatch(1);
+        DataSubscription dataSubscription;
+
+        @Override
+        public void onData(List<TestEntity> data) {
+            if (dataSubscription != null) {
+                System.out.println("Cancelling subscription");
+                dataSubscription.cancel();
+                dataSubscription = null;
+            }
+            // Once here, cancel did not crash.
+            latch.countDown();
+        }
+    }
+
     @Test
     public void testObserver() {
         int[] valuesInt = {2003, 2007, 2002};
         Query<TestEntity> query = box.query().in(simpleInt, valuesInt).build();
         assertEquals(0, query.count());
 
-        query.subscribe().observer(this);
-        assertLatchCountedDown(latch, 5);
-        assertEquals(1, receivedChanges.size());
-        assertEquals(0, receivedChanges.get(0).size());
+        // Initial data on subscription.
+        TestObserver<List<TestEntity>> testObserver = new TestObserver<>();
+        query.subscribe().observer(testObserver);
+        testObserver.assertLatchCountedDown();
+        assertEquals(1, testObserver.receivedChanges.size());
+        assertEquals(0, testObserver.receivedChanges.get(0).size());
 
-        receivedChanges.clear();
-        latch = new CountDownLatch(1);
+        // On put.
+        testObserver.receivedChanges.clear();
+        testObserver.resetLatch();
         putTestEntitiesScalars();
-        assertLatchCountedDown(latch, 5);
+        testObserver.assertLatchCountedDown();
+        assertEquals(1, testObserver.receivedChanges.size());
+        assertEquals(3, testObserver.receivedChanges.get(0).size());
 
-        assertEquals(1, receivedChanges.size());
-        assertEquals(3, receivedChanges.get(0).size());
+        // On remove all.
+        testObserver.receivedChanges.clear();
+        testObserver.resetLatch();
+        box.removeAll();
+        testObserver.assertLatchCountedDown();
+        assertEquals(1, testObserver.receivedChanges.size());
+        assertEquals(0, testObserver.receivedChanges.get(0).size());
+    }
+
+    @Test
+    public void observer_resultsDeliveredInOrder() {
+        Query<TestEntity> query = box.query().build();
+
+        final CountDownLatch latch = new CountDownLatch(2);
+        final AtomicBoolean isLongTransform = new AtomicBoolean(true);
+        final List<Integer> placing = new CopyOnWriteArrayList<>();
+
+        // Block first onData call long enough so second one can race it.
+        DataSubscription subscription = query.subscribe().observer(data -> {
+            if (isLongTransform.compareAndSet(true, false)) {
+                // Wait long enough so publish triggered by transaction
+                // can overtake publish triggered during observer() call.
+                try {
+                    Thread.sleep(200);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+                placing.add(1); // First, during observer() call.
+            } else {
+                placing.add(2); // Second, due to transaction.
+            }
+            latch.countDown();
+        });
+
+        // Trigger publish due to transaction.
+        store.runInTx(() -> putTestEntities(1));
+
+        assertLatchCountedDown(latch, 3);
+        subscription.cancel();
+
+        // Second publish request should still deliver second.
+        assertEquals(2, placing.size());
+        assertEquals(1, (int) placing.get(0));
+        assertEquals(2, (int) placing.get(1));
     }
 
     @Test
@@ -70,15 +158,17 @@ public void testSingle() throws InterruptedException {
         putTestEntitiesScalars();
         int[] valuesInt = {2003, 2007, 2002};
         Query<TestEntity> query = box.query().in(simpleInt, valuesInt).build();
-        query.subscribe().single().observer(this);
-        assertLatchCountedDown(latch, 5);
-        assertEquals(1, receivedChanges.size());
-        assertEquals(3, receivedChanges.get(0).size());
 
-        receivedChanges.clear();
+        TestObserver<List<TestEntity>> testObserver = new TestObserver<>();
+        query.subscribe().single().observer(testObserver);
+        testObserver.assertLatchCountedDown();
+        assertEquals(1, testObserver.receivedChanges.size());
+        assertEquals(3, testObserver.receivedChanges.get(0).size());
+
+        testObserver.receivedChanges.clear();
         putTestEntities(1);
         Thread.sleep(20);
-        assertEquals(0, receivedChanges.size());
+        assertEquals(0, testObserver.receivedChanges.size());
     }
 
     @Test
@@ -86,7 +176,7 @@ public void testTransformer() throws InterruptedException {
         int[] valuesInt = {2003, 2007, 2002};
         Query<TestEntity> query = box.query().in(simpleInt, valuesInt).build();
         assertEquals(0, query.count());
-        final List<Integer> receivedSums = new ArrayList<>();
+        TestObserver<Integer> testObserver = new TestObserver<>();
 
         query.subscribe().transform(source -> {
             int sum = 0;
@@ -94,29 +184,155 @@ public void testTransformer() throws InterruptedException {
                 sum += entity.getSimpleInt();
             }
             return sum;
+        }).observer(testObserver);
+        testObserver.assertLatchCountedDown();
+
+        testObserver.resetLatch();
+        putTestEntitiesScalars();
+        testObserver.assertLatchCountedDown();
+        Thread.sleep(20);
+
+        assertEquals(2, testObserver.receivedChanges.size());
+        assertEquals(0, (int) testObserver.receivedChanges.get(0));
+        assertEquals(2003 + 2007 + 2002, (int) testObserver.receivedChanges.get(1));
+    }
+
+    /**
+     * There is an identical test asserting ObjectClassPublisher at
+     * {@link ObjectClassObserverTest#transform_inOrderOfPublish()}.
+     */
+    @Test
+    public void transform_inOrderOfPublish() {
+        Query<TestEntity> query = box.query().build();
+
+        final CountDownLatch latch = new CountDownLatch(2);
+        final AtomicBoolean isLongTransform = new AtomicBoolean(true);
+        final List<Integer> placing = new CopyOnWriteArrayList<>();
+
+        // Make first transformation take longer than second.
+        DataSubscription subscription = query.subscribe().transform(source -> {
+            if (isLongTransform.compareAndSet(true, false)) {
+                // Wait long enough so publish triggered by transaction
+                // can overtake publish triggered during observer() call.
+                Thread.sleep(200);
+                return 1; // First, during observer() call.
+            }
+            return 2; // Second, due to transaction.
         }).observer(data -> {
-            receivedSums.add(data);
+            placing.add(data);
             latch.countDown();
         });
-        assertLatchCountedDown(latch, 5);
 
-        latch = new CountDownLatch(1);
-        putTestEntitiesScalars();
-        assertLatchCountedDown(latch, 5);
-        Thread.sleep(20);
+        // Trigger publish due to transaction.
+        store.runInTx(() -> putTestEntities(1));
+
+        assertLatchCountedDown(latch, 3);
+        subscription.cancel();
+
+        // Second publish request should still deliver second.
+        assertEquals(2, placing.size());
+        assertEquals(1, (int) placing.get(0));
+        assertEquals(2, (int) placing.get(1));
+    }
+
+    @Test
+    public void queryCloseWaitsOnPublisher() throws InterruptedException {
+        CountDownLatch beforeBlockPublisher = new CountDownLatch(1);
+        CountDownLatch blockPublisher = new CountDownLatch(1);
+        CountDownLatch beforeQueryClose = new CountDownLatch(1);
+        CountDownLatch afterQueryClose = new CountDownLatch(1);
+
+        AtomicBoolean publisherBlocked = new AtomicBoolean(false);
+        AtomicBoolean waitedBeforeQueryClose = new AtomicBoolean(false);
+
+        new Thread(() -> {
+            Query<TestEntity> query = box.query().build();
+            query.subscribe()
+                    .onlyChanges() // prevent initial publish call
+                    .observer(data -> {
+                beforeBlockPublisher.countDown();
+                try {
+                    publisherBlocked.set(blockPublisher.await(1, TimeUnit.SECONDS));
+                } catch (InterruptedException e) {
+                    throw new RuntimeException("Observer was interrupted while waiting", e);
+                }
+            });
+
+            // Trigger the query publisher, prepare so it runs its loop, incl. the query, at least twice
+            // and block it from completing the first loop using the observer.
+            query.publish();
+            query.publish();
 
-        assertEquals(2, receivedSums.size());
-        assertEquals(0, (int) receivedSums.get(0));
-        assertEquals(2003 + 2007 + 2002, (int) receivedSums.get(1));
+            try {
+                waitedBeforeQueryClose.set(beforeQueryClose.await(1, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+                throw new RuntimeException("Thread was interrupted while waiting before closing query", e);
+            }
+            query.close();
+            afterQueryClose.countDown();
+        }).start();
+
+        // Wait for observer to block the publisher
+        assertTrue(beforeBlockPublisher.await(1, TimeUnit.SECONDS));
+        // Start closing the query
+        beforeQueryClose.countDown();
+
+        // While the publisher is blocked, the query close call should block
+        assertFalse(afterQueryClose.await(100, TimeUnit.MILLISECONDS));
+
+        // After the publisher is unblocked and can stop, the query close call should complete
+        blockPublisher.countDown();
+        assertTrue(afterQueryClose.await(100, TimeUnit.MILLISECONDS));
+
+        // Verify latches were triggered due to reaching 0, not due to timeout
+        assertTrue(publisherBlocked.get());
+        assertTrue(waitedBeforeQueryClose.get());
     }
 
     private void putTestEntitiesScalars() {
         putTestEntities(10, null, 2000);
     }
 
-    @Override
-    public void onData(List<TestEntity> queryResult) {
-        receivedChanges.add(queryResult);
-        latch.countDown();
+    public static class TestObserver<T> implements DataObserver<T> {
+
+        List<T> receivedChanges = new CopyOnWriteArrayList<>();
+        CountDownLatch latch = new CountDownLatch(1);
+
+        private void log(String message) {
+            System.out.println("TestObserver: " + message);
+        }
+
+        void printEvents() {
+            int count = receivedChanges.size();
+            log("Received " + count + " event(s):");
+            for (int i = 0; i < count; i++) {
+                T receivedChange = receivedChanges.get(i);
+                if (receivedChange instanceof List) {
+                    List<?> list = (List<?>) receivedChange;
+                    log((i + 1) + "/" + count + ": size=" + list.size()
+                            + "; items=" + Arrays.toString(list.toArray()));
+                }
+            }
+        }
+
+        void resetLatch() {
+            latch = new CountDownLatch(1);
+        }
+
+        void assertLatchCountedDown() {
+            try {
+                assertTrue(latch.await(5, TimeUnit.SECONDS));
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+            printEvents();
+        }
+
+        @Override
+        public void onData(T data) {
+            receivedChanges.add(data);
+            latch.countDown();
+        }
+
     }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java
new file mode 100644
index 00000000..665849cf
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryRelationCountTest.java
@@ -0,0 +1,50 @@
+package io.objectbox.query;
+
+import io.objectbox.relation.AbstractRelationTest;
+import io.objectbox.relation.Customer;
+import io.objectbox.relation.Customer_;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.assertEquals;
+
+public class QueryRelationCountTest extends AbstractRelationTest {
+
+    @Test
+    public void queryRelationCount() {
+        // Customer without orders.
+        putCustomer();
+        // Customer with 2 orders.
+        Customer customerWithOrders = putCustomer();
+        putOrder(customerWithOrders, "First order");
+        putOrder(customerWithOrders, "Second order");
+
+        // Find customer with no orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(0))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(1, customer.size());
+            assertEquals(0, customer.get(0).getOrders().size());
+        }
+
+        // Find customer with two orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(2))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(1, customer.size());
+            assertEquals(2, customer.get(0).getOrders().size());
+        }
+
+        // Find no customer with three orders.
+        try (Query<Customer> query = customerBox
+                .query(Customer_.orders.relationCount(3))
+                .build()) {
+            List<Customer> customer = query.find();
+            assertEquals(0, customer.size());
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryScalarVectorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryScalarVectorTest.java
new file mode 100644
index 00000000..aafc51ce
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryScalarVectorTest.java
@@ -0,0 +1,239 @@
+package io.objectbox.query;
+
+import java.util.Arrays;
+import java.util.List;
+
+import io.objectbox.Property;
+import io.objectbox.TestEntity;
+import org.junit.Test;
+
+import static io.objectbox.TestEntity_.charArray;
+import static io.objectbox.TestEntity_.doubleArray;
+import static io.objectbox.TestEntity_.floatArray;
+import static io.objectbox.TestEntity_.intArray;
+import static io.objectbox.TestEntity_.longArray;
+import static io.objectbox.TestEntity_.shortArray;
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+/**
+ * Tests querying properties that are integer or floating point arrays.
+ */
+public class QueryScalarVectorTest extends AbstractQueryTest {
+
+    /**
+     * Note: byte array is tested separately in {@link QueryTest}.
+     */
+    @Test
+    public void integer() {
+        List<TestEntity> entities = putTestEntitiesScalars();
+        List<Property<TestEntity>> properties = Arrays.asList(
+                shortArray,
+                intArray,
+                longArray
+        );
+        long[] ids = entities.stream().mapToLong(TestEntity::getId).toArray();
+
+        long id5 = ids[4];
+        List<Long> params5 = Arrays.asList(
+                2104L, // short
+                2004L, // int
+                3004L // long
+        );
+        long[] id6To10 = Arrays.stream(ids).filter(value -> value > id5).toArray();
+
+        long id10 = ids[9];
+        List<Long> params10 = Arrays.asList(
+                2109L, // short
+                2009L, // int
+                3009L // long
+        );
+
+        for (int i = 0; i < properties.size(); i++) {
+            Property<TestEntity> property = properties.get(i);
+            Long param5 = params5.get(i);
+            Long param10 = params10.get(i);
+
+            // "greater" which behaves like "has element greater".
+            try (Query<TestEntity> query = box.query()
+                    .greater(property, 3010)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, param5);
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "greater or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .greaterOrEqual(property, param10)
+                    .build()) {
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // "less" which behaves like "has element less".
+            try (Query<TestEntity> query = box.query()
+                    .less(property, -3010)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, -param5);
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "less or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .lessOrEqual(property, -param10)
+                    .build()) {
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // Note: "equal" for scalar arrays is actually "contains element".
+            try (Query<TestEntity> query = box.query()
+                    .equal(property, -1)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, param5);
+                assertEquals(id5, query.findUniqueId());
+            }
+
+            // Note: "not equal" for scalar arrays does not do anything useful.
+            try (Query<TestEntity> query = box.query()
+                    .notEqual(property, param5)
+                    .build()) {
+                assertArrayEquals(ids, query.findIds());
+            }
+        }
+
+    }
+
+    @Test
+    public void charArray() {
+        List<TestEntity> entities = putTestEntitiesStrings();
+        long[] ids = entities.stream().mapToLong(TestEntity::getId).toArray();
+
+        Property<TestEntity> property = charArray;
+        long id2 = entities.get(1).getId();
+        long id4 = entities.get(3).getId();
+        long[] id3to5 = Arrays.stream(ids).filter(value -> value > id2).toArray();
+
+        // "greater" which behaves like "has element greater".
+        try (Query<TestEntity> query = box.query()
+                .greater(property, 'x')
+                .build()) {
+            assertEquals(0, query.findUniqueId());
+
+            query.setParameter(property, 'p' /* apple */);
+            assertArrayEquals(id3to5, query.findIds());
+        }
+        // "greater or equal", only check equal
+        try (Query<TestEntity> query = box.query()
+                .greaterOrEqual(property, 's' /* banana milk shake */)
+                .build()) {
+            assertEquals(id4, query.findUniqueId());
+        }
+
+        // "less" which behaves like "has element less".
+        long[] id4And5 = new long[]{ids[3], ids[4]};
+        try (Query<TestEntity> query = box.query()
+                .less(property, ' ')
+                .build()) {
+            assertEquals(0, query.findUniqueId());
+
+            query.setParameter(property, 'a');
+            assertArrayEquals(id4And5, query.findIds());
+        }
+        // "less or equal", only check equal
+        try (Query<TestEntity> query = box.query()
+                .lessOrEqual(property, ' ')
+                .build()) {
+            assertArrayEquals(id4And5, query.findIds());
+        }
+
+        // Note: "equal" for scalar arrays is actually "contains element".
+        try (Query<TestEntity> query = box.query()
+                .equal(property, 'x')
+                .build()) {
+            assertEquals(0, query.findUniqueId());
+            
+            query.setParameter(property, 'p' /* apple */);
+            assertEquals(id2, query.findUniqueId());
+        }
+
+        // Note: "not equal" for scalar arrays does not do anything useful.
+        try (Query<TestEntity> query = box.query()
+                .notEqual(property, 'p' /* apple */)
+                .build()) {
+            assertArrayEquals(
+                    entities.stream().mapToLong(TestEntity::getId).toArray(),
+                    query.findIds()
+            );
+        }
+    }
+
+    @Test
+    public void floatingPoint() {
+        List<TestEntity> entities = putTestEntitiesScalars();
+        List<Property<TestEntity>> properties = Arrays.asList(
+                floatArray,
+                doubleArray
+        );
+        long[] ids = entities.stream().mapToLong(TestEntity::getId).toArray();
+
+        long id5 = ids[4];
+        List<Double> params5 = Arrays.asList(
+                400.4, // float
+                (double) (2000 + 2004 / 100f) // double
+        );
+        long[] id6To10 = Arrays.stream(ids).filter(value -> value > id5).toArray();
+
+        long id10 = ids[9];
+        List<Double> params10 = Arrays.asList(
+                400.9, // float
+                (double) (2000 + 2009 / 100f) // double
+        );
+
+        for (int i = 0; i < properties.size(); i++) {
+            Property<TestEntity> property = properties.get(i);
+            System.out.println(property);
+            Double param5 = params5.get(i);
+            Double param10 = params10.get(i);
+
+            // "greater" which behaves like "has element greater".
+            try (Query<TestEntity> query = box.query()
+                    .greater(property, 2021.0)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, param5);
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "greater or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .greaterOrEqual(property, param10)
+                    .build()) {
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // "less" which behaves like "has element less".
+            try (Query<TestEntity> query = box.query()
+                    .less(property, -param5)
+                    .build()) {
+                assertArrayEquals(id6To10, query.findIds());
+            }
+            // "less or equal", only check equal
+            try (Query<TestEntity> query = box.query()
+                    .lessOrEqual(property, -2021.0)
+                    .build()) {
+                assertEquals(0, query.findUniqueId());
+
+                query.setParameter(property, -param10);
+                assertEquals(id10, query.findUniqueId());
+            }
+
+            // "equal" which is actually "between" for floating point, is not supported.
+            assertThrows(IllegalArgumentException.class, () -> box.query().equal(property, param5, 0));
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java
index 51ee4cfb..3c618e16 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright © 2016 ObjectBox Ltd. <https://objectbox.io/>
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -17,29 +17,25 @@
 package io.objectbox.query;
 
 import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
 
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.List;
 
-import javax.annotation.Nullable;
-
 import io.objectbox.Box;
 import io.objectbox.BoxStore;
 import io.objectbox.BoxStoreBuilder;
-import io.objectbox.DebugFlags;
 import io.objectbox.TestEntity;
 import io.objectbox.TestEntity_;
-import io.objectbox.TxCallback;
+import io.objectbox.TestUtils;
 import io.objectbox.exception.DbExceptionListener;
 import io.objectbox.exception.NonUniqueResultException;
 import io.objectbox.query.QueryBuilder.StringOrder;
-import io.objectbox.relation.MyObjectBox;
-import io.objectbox.relation.Order;
-import io.objectbox.relation.Order_;
 
 
+import static io.objectbox.TestEntity_.date;
 import static io.objectbox.TestEntity_.simpleBoolean;
 import static io.objectbox.TestEntity_.simpleByteArray;
 import static io.objectbox.TestEntity_.simpleFloat;
@@ -47,63 +43,203 @@
 import static io.objectbox.TestEntity_.simpleLong;
 import static io.objectbox.TestEntity_.simpleShort;
 import static io.objectbox.TestEntity_.simpleString;
+import static io.objectbox.TestEntity_.simpleStringArray;
+import static io.objectbox.TestEntity_.stringObjectMap;
+import static org.junit.Assert.assertArrayEquals;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 
 public class QueryTest extends AbstractQueryTest {
 
+    @Test
+    public void createIfStoreClosed_throws() {
+        store.close();
+
+        IllegalStateException ex = assertThrows(
+                IllegalStateException.class,
+                () -> box.query()
+        );
+        assertEquals("Store is closed", ex.getMessage());
+    }
+
     @Test
     public void testBuild() {
-        Query<TestEntity> query = box.query().build();
-        assertNotNull(query);
-    }
-
-    @Test(expected = IllegalStateException.class)
-    public void testBuildTwice() {
-        QueryBuilder<TestEntity> queryBuilder = box.query();
-        for (int i = 0; i < 2; i++) {
-            // calling any builder method after build should fail
-            // note: not calling all variants for different types
-            queryBuilder.isNull(TestEntity_.simpleString);
-            queryBuilder.and();
-            queryBuilder.notNull(TestEntity_.simpleString);
-            queryBuilder.or();
-            queryBuilder.equal(TestEntity_.simpleBoolean, true);
-            queryBuilder.notEqual(TestEntity_.simpleBoolean, true);
-            queryBuilder.less(TestEntity_.simpleInt, 42);
-            queryBuilder.greater(TestEntity_.simpleInt, 42);
-            queryBuilder.between(TestEntity_.simpleInt, 42, 43);
-            queryBuilder.in(TestEntity_.simpleInt, new int[]{42});
-            queryBuilder.notIn(TestEntity_.simpleInt, new int[]{42});
-            queryBuilder.contains(TestEntity_.simpleString, "42");
-            queryBuilder.startsWith(TestEntity_.simpleString, "42");
-            queryBuilder.order(TestEntity_.simpleInt);
-            queryBuilder.build().find();
+        try (Query<TestEntity> query = box.query().build()) {
+            assertNotNull(query);
         }
     }
 
+    @Test
+    public void useAfterBuild_fails() {
+        QueryBuilder<TestEntity> builder = box.query();
+        Query<TestEntity> query = builder.build();
+
+        // Calling any builder method after build should fail.
+        // note: not calling all variants for different types.
+        assertThrowsBuilderClosed(() -> builder.isNull(TestEntity_.simpleString));
+        assertThrowsBuilderClosed(builder::and);
+        assertThrowsBuilderClosed(() -> builder.notNull(TestEntity_.simpleString));
+        assertThrowsBuilderClosed(builder::or);
+        assertThrowsBuilderClosed(() -> builder.equal(TestEntity_.simpleBoolean, true));
+        assertThrowsBuilderClosed(() -> builder.notEqual(TestEntity_.simpleBoolean, true));
+        assertThrowsBuilderClosed(() -> builder.less(TestEntity_.simpleInt, 42));
+        assertThrowsBuilderClosed(() -> builder.greater(TestEntity_.simpleInt, 42));
+        assertThrowsBuilderClosed(() -> builder.between(TestEntity_.simpleInt, 42, 43));
+        assertThrowsBuilderClosed(() -> builder.in(TestEntity_.simpleInt, new int[]{42}));
+        assertThrowsBuilderClosed(() -> builder.notIn(TestEntity_.simpleInt, new int[]{42}));
+        assertThrowsBuilderClosed(() -> builder.contains(TestEntity_.simpleString, "42", StringOrder.CASE_INSENSITIVE));
+        assertThrowsBuilderClosed(() -> builder.startsWith(TestEntity_.simpleString, "42", StringOrder.CASE_SENSITIVE));
+        assertThrowsBuilderClosed(() -> builder.order(TestEntity_.simpleInt));
+        assertThrowsBuilderClosed(builder::build);
+
+        query.close();
+    }
+
+    private void assertThrowsBuilderClosed(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("This QueryBuilder has already been closed. Please use a new instance.", ex.getMessage());
+    }
+
+    @Test
+    public void useAfterQueryClose_fails() {
+        Query<TestEntity> query = box.query().build();
+        query.close();
+
+        assertThrowsQueryIsClosed(query::count);
+        assertThrowsQueryIsClosed(query::describe);
+        assertThrowsQueryIsClosed(query::describeParameters);
+        assertThrowsQueryIsClosed(query::findFirst);
+        assertThrowsQueryIsClosed(query::findUnique);
+        assertThrowsQueryIsClosed(query::find);
+        assertThrowsQueryIsClosed(() -> query.find(0, 1));
+        assertThrowsQueryIsClosed(query::findFirstId);
+        assertThrowsQueryIsClosed(query::findUniqueId);
+        assertThrowsQueryIsClosed(query::findIds);
+        assertThrowsQueryIsClosed(() -> query.findIds(0, 1));
+        assertThrowsQueryIsClosed(query::findLazy);
+        assertThrowsQueryIsClosed(query::findLazyCached);
+        assertThrowsQueryIsClosed(query::remove);
+
+        // For setParameter(s) the native method is not actually called, so fine to use incorrect alias and property.
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", "value"));
+        assertThrowsQueryIsClosed(() -> query.setParameters("none", "a", "b"));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", 1));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new int[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new long[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameters("none", 1, 2));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", 1.0));
+        assertThrowsQueryIsClosed(() -> query.setParameters("none", 1.0, 2.0));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new String[]{"a", "b"}));
+        assertThrowsQueryIsClosed(() -> query.setParameter("none", new byte[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, "value"));
+        assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, "a", "b"));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, 1));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new int[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new long[]{1, 2}));
+        assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, 1, 2));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, 1.0));
+        assertThrowsQueryIsClosed(() -> query.setParameters(simpleString, 1.0, 2.0));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new String[]{"a", "b"}));
+        assertThrowsQueryIsClosed(() -> query.setParameter(simpleString, new byte[]{1, 2}));
+
+        // find would throw once first results are obtained, but shouldn't allow creating an observer to begin with.
+        assertThrowsQueryIsClosed(() -> query.subscribe().observer(data -> {
+        }));
+    }
+
+    private void assertThrowsQueryIsClosed(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("This query is closed. Build and use a new one.", ex.getMessage());
+    }
+
+    @Test
+    public void useAfterStoreClose_failsIfUsingStore() {
+        Query<TestEntity> query = box.query(
+                simpleString.equal("")
+                        .and(stringObjectMap.equalKeyValue("", "", StringOrder.CASE_SENSITIVE))
+                        .and(simpleInt.equal(0))
+                        .and(simpleInt.oneOf(new int[]{0}).alias("oneOf4"))
+                        .and(simpleLong.oneOf(new long[]{0}).alias("oneOf8"))
+                        .and(simpleInt.between(0, 0).alias("between"))
+                        .and(simpleString.oneOf(new String[]{""}).alias("oneOfS"))
+                        .and(simpleByteArray.equal(new byte[]{0}))
+        ).build();
+        store.close();
+
+        // All methods accessing the store throw.
+        assertThrowsStoreIsClosed(query::count);
+        assertThrowsStoreIsClosed(query::findFirst);
+        assertThrowsStoreIsClosed(query::findUnique);
+        assertThrowsStoreIsClosed(query::find);
+        assertThrowsStoreIsClosed(() -> query.find(0, 1));
+        assertThrowsStoreIsClosed(query::findFirstId);
+        assertThrowsStoreIsClosed(query::findUniqueId);
+        assertThrowsStoreIsClosed(query::findIds);
+        assertThrowsStoreIsClosed(() -> query.findIds(0, 1));
+        assertThrowsStoreIsClosed(query::findLazy);
+        assertThrowsStoreIsClosed(query::findLazyCached);
+        assertThrowsStoreIsClosed(query::remove);
+        assertThrowsStoreIsClosed(() -> query.subscribe().observer(data -> {
+        }));
+
+        // describe works, but returns no property info.
+        assertEquals("Query for entity <deleted entity type> with 15 conditions", query.describe());
+        // describeParameters does not work.
+        IllegalStateException exc = assertThrows(IllegalStateException.class, query::describeParameters);
+        assertEquals("Query cannot be used after entity type was deleted (e.g. store was closed)", exc.getMessage());
+
+        // setParameter throws.
+        assertThrowsEntityDeleted(() -> query.setParameter(simpleString, "value"));
+        assertThrowsEntityDeleted(() -> query.setParameters(stringObjectMap, "a", "b"));
+        assertThrowsEntityDeleted(() -> query.setParameter(simpleInt, 1));
+        assertThrowsEntityDeleted(() -> query.setParameter("oneOf4", new int[]{1, 2}));
+        assertThrowsEntityDeleted(() -> query.setParameter("oneOf8", new long[]{1, 2}));
+        assertThrowsEntityDeleted(() -> query.setParameters("between", 1, 2));
+        assertThrowsEntityDeleted(() -> query.setParameter(simpleInt, 1.0));
+        assertThrowsEntityDeleted(() -> query.setParameters("between", 1.0, 2.0));
+        assertThrowsEntityDeleted(() -> query.setParameter("oneOfS", new String[]{"a", "b"}));
+        assertThrowsEntityDeleted(() -> query.setParameter(simpleByteArray, new byte[]{1, 2}));
+    }
+
+    private void assertThrowsStoreIsClosed(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("Store is closed", ex.getMessage());
+    }
+
+    private void assertThrowsEntityDeleted(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("Query cannot be used after entity type was deleted (e.g. store was closed)", ex.getMessage());
+    }
+
     @Test
     public void testNullNotNull() {
         List<TestEntity> scalars = putTestEntitiesScalars();
         List<TestEntity> strings = putTestEntitiesStrings();
-        assertEquals(strings.size(), box.query().notNull(simpleString).build().count());
-        assertEquals(scalars.size(), box.query().isNull(simpleString).build().count());
+        try (Query<TestEntity> notNull = box.query(simpleString.notNull()).build()) {
+            assertEquals(strings.size(), notNull.count());
+        }
+        try (Query<TestEntity> isNull = box.query(simpleString.isNull()).build()) {
+            assertEquals(scalars.size(), isNull.count());
+        }
     }
 
     @Test
     public void testScalarEqual() {
         putTestEntitiesScalars();
 
-        Query<TestEntity> query = box.query().equal(simpleInt, 2007).build();
-        assertEquals(1, query.count());
-        assertEquals(8, query.findFirst().getId());
-        assertEquals(8, query.findUnique().getId());
-        List<TestEntity> all = query.find();
+        List<TestEntity> all;
+        try (Query<TestEntity> query = box.query().equal(simpleInt, 2007).build()) {
+            assertEquals(1, query.count());
+            assertEquals(8, getFirstNotNull(query).getId());
+            assertEquals(8, getUniqueNotNull(query).getId());
+            all = query.find();
+        }
         assertEquals(1, all.size());
         assertEquals(8, all.get(0).getId());
     }
@@ -112,42 +248,86 @@ public void testScalarEqual() {
     public void testBooleanEqual() {
         putTestEntitiesScalars();
 
-        Query<TestEntity> query = box.query().equal(simpleBoolean, true).build();
-        assertEquals(5, query.count());
-        assertEquals(1, query.findFirst().getId());
-        query.setParameter(simpleBoolean, false);
-        assertEquals(5, query.count());
-        assertEquals(2, query.findFirst().getId());
+        try (Query<TestEntity> query = box.query().equal(simpleBoolean, true).build()) {
+            assertEquals(5, query.count());
+            assertEquals(1, getFirstNotNull(query).getId());
+            query.setParameter(simpleBoolean, false);
+            assertEquals(5, query.count());
+            assertEquals(2, getFirstNotNull(query).getId());
+        }
+
+        // Again, but using alias
+        try (Query<TestEntity> aliasQuery = box.query().equal(simpleBoolean, true).parameterAlias("bool").build()) {
+            assertEquals(5, aliasQuery.count());
+            assertEquals(1, getFirstNotNull(aliasQuery).getId());
+            aliasQuery.setParameter("bool", false);
+            assertEquals(5, aliasQuery.count());
+            assertEquals(2, getFirstNotNull(aliasQuery).getId());
+        }
     }
 
     @Test
     public void testNoConditions() {
         List<TestEntity> entities = putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().build();
-        List<TestEntity> all = query.find();
-        assertEquals(entities.size(), all.size());
-        assertEquals(entities.size(), query.count());
+        try (Query<TestEntity> query = box.query().build()) {
+            List<TestEntity> all = query.find();
+            assertEquals(entities.size(), all.size());
+            assertEquals(entities.size(), query.count());
+        }
     }
 
     @Test
     public void testScalarNotEqual() {
         List<TestEntity> entities = putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().notEqual(simpleInt, 2007).notEqual(simpleInt, 2002).build();
-        assertEquals(entities.size() - 2, query.count());
+        try (Query<TestEntity> query = box.query().notEqual(simpleInt, 2007).notEqual(simpleInt, 2002).build()) {
+            assertEquals(entities.size() - 2, query.count());
+        }
     }
 
     @Test
     public void testScalarLessAndGreater() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().greater(simpleInt, 2003).less(simpleShort, 2107).build();
-        assertEquals(3, query.count());
+        try (Query<TestEntity> query = box.query().greater(simpleInt, 2003).less(simpleShort, 2107).build()) {
+            assertEquals(3, query.count());
+        }
+    }
+
+    @Test
+    public void integer_lessAndGreater_works() {
+        putTestEntitiesScalars();
+        int value = 2004;
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleInt, value),
+                4,
+                (index, item) -> assertTrue(item.getSimpleInt() < value)
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleInt, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleInt() > value)
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleInt, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleInt() <= value)
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleInt, value),
+                6,
+                (index, item) -> assertTrue(item.getSimpleInt() >= value)
+        );
     }
 
     @Test
     public void testScalarBetween() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().between(simpleInt, 2003, 2006).build();
-        assertEquals(4, query.count());
+        try (Query<TestEntity> query = box.query().between(simpleInt, 2003, 2006).build()) {
+            assertEquals(4, query.count());
+        }
     }
 
     @Test
@@ -155,16 +335,17 @@ public void testIntIn() {
         putTestEntitiesScalars();
 
         int[] valuesInt = {1, 1, 2, 3, 2003, 2007, 2002, -1};
-        Query<TestEntity> query = box.query().in(simpleInt, valuesInt).parameterAlias("int").build();
-        assertEquals(3, query.count());
+        try (Query<TestEntity> query = box.query().in(simpleInt, valuesInt).parameterAlias("int").build()) {
+            assertEquals(3, query.count());
 
-        int[] valuesInt2 = {2003};
-        query.setParameters(simpleInt, valuesInt2);
-        assertEquals(1, query.count());
+            int[] valuesInt2 = {2003};
+            query.setParameter(simpleInt, valuesInt2);
+            assertEquals(1, query.count());
 
-        int[] valuesInt3 = {2003, 2007};
-        query.setParameters("int", valuesInt3);
-        assertEquals(2, query.count());
+            int[] valuesInt3 = {2003, 2007};
+            query.setParameter("int", valuesInt3);
+            assertEquals(2, query.count());
+        }
     }
 
     @Test
@@ -172,16 +353,17 @@ public void testLongIn() {
         putTestEntitiesScalars();
 
         long[] valuesLong = {1, 1, 2, 3, 3003, 3007, 3002, -1};
-        Query<TestEntity> query = box.query().in(simpleLong, valuesLong).parameterAlias("long").build();
-        assertEquals(3, query.count());
+        try (Query<TestEntity> query = box.query().in(simpleLong, valuesLong).parameterAlias("long").build()) {
+            assertEquals(3, query.count());
 
-        long[] valuesLong2 = {3003};
-        query.setParameters(simpleLong, valuesLong2);
-        assertEquals(1, query.count());
+            long[] valuesLong2 = {3003};
+            query.setParameter(simpleLong, valuesLong2);
+            assertEquals(1, query.count());
 
-        long[] valuesLong3 = {3003, 3007};
-        query.setParameters("long", valuesLong3);
-        assertEquals(2, query.count());
+            long[] valuesLong3 = {3003, 3007};
+            query.setParameter("long", valuesLong3);
+            assertEquals(2, query.count());
+        }
     }
 
     @Test
@@ -189,16 +371,17 @@ public void testIntNotIn() {
         putTestEntitiesScalars();
 
         int[] valuesInt = {1, 1, 2, 3, 2003, 2007, 2002, -1};
-        Query<TestEntity> query = box.query().notIn(simpleInt, valuesInt).parameterAlias("int").build();
-        assertEquals(7, query.count());
+        try (Query<TestEntity> query = box.query().notIn(simpleInt, valuesInt).parameterAlias("int").build()) {
+            assertEquals(7, query.count());
 
-        int[] valuesInt2 = {2003};
-        query.setParameters(simpleInt, valuesInt2);
-        assertEquals(9, query.count());
+            int[] valuesInt2 = {2003};
+            query.setParameter(simpleInt, valuesInt2);
+            assertEquals(9, query.count());
 
-        int[] valuesInt3 = {2003, 2007};
-        query.setParameters("int", valuesInt3);
-        assertEquals(8, query.count());
+            int[] valuesInt3 = {2003, 2007};
+            query.setParameter("int", valuesInt3);
+            assertEquals(8, query.count());
+        }
     }
 
     @Test
@@ -206,122 +389,309 @@ public void testLongNotIn() {
         putTestEntitiesScalars();
 
         long[] valuesLong = {1, 1, 2, 3, 3003, 3007, 3002, -1};
-        Query<TestEntity> query = box.query().notIn(simpleLong, valuesLong).parameterAlias("long").build();
-        assertEquals(7, query.count());
+        try (Query<TestEntity> query = box.query().notIn(simpleLong, valuesLong).parameterAlias("long").build()) {
+            assertEquals(7, query.count());
 
-        long[] valuesLong2 = {3003};
-        query.setParameters(simpleLong, valuesLong2);
-        assertEquals(9, query.count());
+            long[] valuesLong2 = {3003};
+            query.setParameter(simpleLong, valuesLong2);
+            assertEquals(9, query.count());
 
-        long[] valuesLong3 = {3003, 3007};
-        query.setParameters("long", valuesLong3);
-        assertEquals(8, query.count());
+            long[] valuesLong3 = {3003, 3007};
+            query.setParameter("long", valuesLong3);
+            assertEquals(8, query.count());
+        }
     }
 
     @Test
-    public void testOffsetLimit() {
+    public void offset_limit_find() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().greater(simpleInt, 2002).less(simpleShort, 2108).build();
-        assertEquals(5, query.count());
-        assertEquals(4, query.find(1, 0).size());
-        assertEquals(1, query.find(4, 0).size());
-        assertEquals(2, query.find(0, 2).size());
-        List<TestEntity> list = query.find(1, 2);
-        assertEquals(2, list.size());
-        assertEquals(2004, list.get(0).getSimpleInt());
-        assertEquals(2005, list.get(1).getSimpleInt());
+        try (Query<TestEntity> query = box.query().greater(simpleInt, 2002).less(simpleShort, 2108).build()) {
+            assertEquals(5, query.count());
+
+            assertEquals(4, query.find(1, 0).size());
+            assertEquals(1, query.find(4, 0).size());
+            assertEquals(2, query.find(0, 2).size());
+            List<TestEntity> list = query.find(1, 2);
+            assertEquals(2, list.size());
+            assertEquals(2004, list.get(0).getSimpleInt());
+            assertEquals(2005, list.get(1).getSimpleInt());
+
+            OffsetLimitFunction find = (offset, limit) -> query.find(offset, limit).size();
+            assertOffsetLimitEdgeCases(find);
+        }
+    }
+
+    @Test
+    public void offset_limit_findIds() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query().greater(simpleInt, 2002).less(simpleShort, 2108).build()) {
+            assertEquals(5, query.count());
+
+            assertEquals(4, query.findIds(1, 0).length);
+            assertEquals(1, query.findIds(4, 0).length);
+            assertEquals(2, query.findIds(0, 2).length);
+            long[] list = query.findIds(1, 2);
+            assertEquals(2, list.length);
+            assertEquals(5, list[0]);
+            assertEquals(6, list[1]);
+
+            OffsetLimitFunction findIds = (offset, limit) -> query.findIds(offset, limit).length;
+            assertOffsetLimitEdgeCases(findIds);
+        }
+    }
+
+    private interface OffsetLimitFunction {
+        int applyAndCount(long offset, long limit);
+    }
+
+    private void assertOffsetLimitEdgeCases(OffsetLimitFunction function) {
+        // Max value
+        if (TestUtils.is32BitJVM()) {
+            // When running 32-bit ObjectBox limit and offset max is limited to 32-bit unsigned integer.
+            IllegalArgumentException ex = assertThrows(IllegalArgumentException.class,
+                    () -> function.applyAndCount(Long.MAX_VALUE, Long.MAX_VALUE));
+            assertEquals("Invalid offset (9223372036854775807): exceeds the maximum value allowed on this platform (4294967295)",
+                    ex.getMessage());
+            // Ensure max allowed value works.
+            // Note: currently offset + limit must not exceed 32-bit unsigned integer max.
+            assertEquals(0, function.applyAndCount(Integer.MAX_VALUE * 2L + 1, 0));
+            assertEquals(5, function.applyAndCount(0, Integer.MAX_VALUE * 2L + 1));
+        } else {
+            // 64-bit JVM
+            assertEquals(0, function.applyAndCount(Long.MAX_VALUE, Long.MAX_VALUE));
+        }
+
+        // Min value
+        IllegalArgumentException exOffset = assertThrows(IllegalArgumentException.class,
+                () -> function.applyAndCount(Long.MIN_VALUE, 0));
+        assertEquals("Invalid offset (-9223372036854775808): must be zero or positive", exOffset.getMessage());
+        IllegalArgumentException exLimit = assertThrows(IllegalArgumentException.class,
+                () -> function.applyAndCount(0, Long.MIN_VALUE));
+        assertEquals("Invalid limit (-9223372036854775808): must be zero or positive", exLimit.getMessage());
     }
 
     @Test
     public void testString() {
         List<TestEntity> entities = putTestEntitiesStrings();
         int count = entities.size();
-        assertEquals(1, box.query().equal(simpleString, "banana").build().findUnique().getId());
-        assertEquals(count - 1, box.query().notEqual(simpleString, "banana").build().count());
-        assertEquals(4, box.query().startsWith(simpleString, "ba").endsWith(simpleString, "shake").build().findUnique()
-                .getId());
-        assertEquals(2, box.query().contains(simpleString, "nana").build().count());
+        
+        try (Query<TestEntity> equal = box.query()
+                .equal(simpleString, "banana", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(1, getUniqueNotNull(equal).getId());
+        }
+        try (Query<TestEntity> notEqual = box.query()
+                .notEqual(simpleString, "banana", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(count - 1, notEqual.count());
+        }
+        try (Query<TestEntity> startsEndsWith = box.query()
+                .startsWith(simpleString, "ba", StringOrder.CASE_INSENSITIVE)
+                .endsWith(simpleString, "shake", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(4, getUniqueNotNull(startsEndsWith).getId());
+        }
+
+        // contains
+        try (Query<TestEntity> contains = box.query()
+                .contains(simpleString, "nana", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(2, contains.count());
+        }
+        // Verify case-sensitive setting has no side effects for non-ASCII characters
+        box.put(createTestEntity("Note that Îñţérñåţîöñåļîžåţîờñ is key", 6));
+        try (Query<TestEntity> contains = box.query()
+                .contains(simpleString, "Îñţérñåţîöñåļîžåţîờñ", StringOrder.CASE_SENSITIVE)
+                .build()) {
+            assertEquals(1, contains.count());
+        }
+        try (Query<TestEntity> contains = box.query()
+                .contains(simpleString, "Îñţérñåţîöñåļîžåţîờñ", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(1, contains.count());
+        }
+    }
+
+    @Test
+    public void testStringArray() {
+        putTestEntitiesStrings();
+
+        // Using contains should not work on String array.
+        Exception exception = assertThrows(UnsupportedOperationException.class,
+                () -> box.query().contains(simpleStringArray, "banana", StringOrder.CASE_INSENSITIVE));
+        assertEquals("For String[] only containsElement() is supported at this time.", exception.getMessage());
+
+        // containsElement(prop, value) matches if value is equal to one of the array items.
+        // Verify by not matching entity where 'banana' is only a substring of an array item ('banana milk shake').
+        List<TestEntity> results;
+        try (Query<TestEntity> containsElement = box.query()
+                .containsElement(simpleStringArray, "banana", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            results = containsElement.find();
+        }
+        assertEquals(1, results.size());
+        assertEquals("banana", results.get(0).getSimpleStringArray()[0]);
     }
 
     @Test
     public void testStringLess() {
         putTestEntitiesStrings();
         putTestEntity("BaNaNa Split", 100);
-        Query<TestEntity> query = box.query().less(simpleString, "banana juice").order(simpleString).build();
-        List<TestEntity> entities = query.find();
-        assertEquals(2, entities.size());
-        assertEquals("apple", entities.get(0).getSimpleString());
-        assertEquals("banana", entities.get(1).getSimpleString());
-
-        query.setParameter(simpleString, "BANANA MZ");
-        entities = query.find();
+        List<TestEntity> entities;
+        try (Query<TestEntity> query = box.query()
+                .less(simpleString, "banana juice", StringOrder.CASE_INSENSITIVE)
+                .order(simpleString)
+                .build()) {
+            entities = query.find();
+            assertEquals(2, entities.size());
+            assertEquals("apple", entities.get(0).getSimpleString());
+            assertEquals("banana", entities.get(1).getSimpleString());
+
+            query.setParameter(simpleString, "BANANA MZ");
+            entities = query.find();
+        }
         assertEquals(3, entities.size());
         assertEquals("apple", entities.get(0).getSimpleString());
         assertEquals("banana", entities.get(1).getSimpleString());
         assertEquals("banana milk shake", entities.get(2).getSimpleString());
 
         // Case sensitive
-        query = box.query().less(simpleString, "BANANA", StringOrder.CASE_SENSITIVE).order(simpleString).build();
-        assertEquals(0, query.count());
-
-        query.setParameter(simpleString, "banana a");
-        entities = query.find();
+        try (Query<TestEntity> queryCaseSens = box.query()
+                .less(simpleString, "BANANA", StringOrder.CASE_SENSITIVE)
+                .order(simpleString)
+                .build()) {
+            assertEquals(0, queryCaseSens.count());
+
+            queryCaseSens.setParameter(simpleString, "banana a");
+            entities = queryCaseSens.find();
+        }
         assertEquals(3, entities.size());
         assertEquals("apple", entities.get(0).getSimpleString());
         assertEquals("banana", entities.get(1).getSimpleString());
         assertEquals("BaNaNa Split", entities.get(2).getSimpleString());
     }
 
+    @Test
+    public void string_lessOrEqual_works() {
+        putTestEntitiesStrings();
+
+        ListItemAsserter<TestEntity> lessOrEqualAsserter = (index, item) -> {
+            if (index == 0) assertEquals("apple", item.getSimpleString());
+            if (index == 1) assertEquals("banana", item.getSimpleString());
+            if (index == 2) assertEquals("banana milk shake", item.getSimpleString());
+        };
+
+        buildFindAndAssert(
+                box.query()
+                        .lessOrEqual(TestEntity_.simpleString, "BANANA MILK SHAKE", StringOrder.CASE_INSENSITIVE)
+                        .order(TestEntity_.simpleString),
+                3,
+                lessOrEqualAsserter
+        );
+
+        buildFindAndAssert(
+                box.query()
+                        .lessOrEqual(TestEntity_.simpleString, "banana milk shake", StringOrder.CASE_SENSITIVE)
+                        .order(TestEntity_.simpleString),
+                3,
+                lessOrEqualAsserter
+        );
+    }
+
     @Test
     public void testStringGreater() {
         putTestEntitiesStrings();
         putTestEntity("FOO", 100);
-        Query<TestEntity> query = box.query().greater(simpleString, "banana juice").order(simpleString).build();
-        List<TestEntity> entities = query.find();
-        assertEquals(4, entities.size());
-        assertEquals("banana milk shake", entities.get(0).getSimpleString());
-        assertEquals("bar", entities.get(1).getSimpleString());
-        assertEquals("FOO", entities.get(2).getSimpleString());
-        assertEquals("foo bar", entities.get(3).getSimpleString());
-
-        query.setParameter(simpleString, "FO");
-        entities = query.find();
+        List<TestEntity> entities;
+        try (Query<TestEntity> query = box.query()
+                .greater(simpleString, "banana juice", StringOrder.CASE_INSENSITIVE)
+                .order(simpleString)
+                .build()) {
+            entities = query.find();
+            assertEquals(4, entities.size());
+            assertEquals("banana milk shake", entities.get(0).getSimpleString());
+            assertEquals("bar", entities.get(1).getSimpleString());
+            assertEquals("FOO", entities.get(2).getSimpleString());
+            assertEquals("foo bar", entities.get(3).getSimpleString());
+
+            query.setParameter(simpleString, "FO");
+            entities = query.find();
+        }
         assertEquals(2, entities.size());
         assertEquals("FOO", entities.get(0).getSimpleString());
         assertEquals("foo bar", entities.get(1).getSimpleString());
 
         // Case sensitive
-        query = box.query().greater(simpleString, "banana", StringOrder.CASE_SENSITIVE).order(simpleString).build();
-        entities = query.find();
+        try (Query<TestEntity> queryCaseSens = box.query()
+                .greater(simpleString, "banana", StringOrder.CASE_SENSITIVE)
+                .order(simpleString)
+                .build()) {
+            entities = queryCaseSens.find();
+        }
         assertEquals(3, entities.size());
         assertEquals("banana milk shake", entities.get(0).getSimpleString());
         assertEquals("bar", entities.get(1).getSimpleString());
         assertEquals("foo bar", entities.get(2).getSimpleString());
     }
 
+    @Test
+    public void string_greaterOrEqual_works() {
+        putTestEntitiesStrings();
+
+        ListItemAsserter<TestEntity> greaterOrEqualAsserter = (index, item) -> {
+            if (index == 0) assertEquals("banana milk shake", item.getSimpleString());
+            if (index == 1) assertEquals("bar", item.getSimpleString());
+            if (index == 2) assertEquals("foo bar", item.getSimpleString());
+        };
+
+        buildFindAndAssert(
+                box.query()
+                        .greaterOrEqual(TestEntity_.simpleString, "BANANA MILK SHAKE", StringOrder.CASE_INSENSITIVE)
+                        .order(TestEntity_.simpleString),
+                3,
+                greaterOrEqualAsserter
+        );
+
+        buildFindAndAssert(
+                box.query()
+                        .greaterOrEqual(TestEntity_.simpleString, "banana milk shake", StringOrder.CASE_SENSITIVE)
+                        .order(TestEntity_.simpleString),
+                3,
+                greaterOrEqualAsserter
+        );
+    }
+
     @Test
     public void testStringIn() {
         putTestEntitiesStrings();
         putTestEntity("BAR", 100);
         String[] values = {"bar", "foo bar"};
-        Query<TestEntity> query = box.query().in(simpleString, values).order(simpleString, OrderFlags.CASE_SENSITIVE)
-                .build();
-        List<TestEntity> entities = query.find();
-        assertEquals(3, entities.size());
-        assertEquals("BAR", entities.get(0).getSimpleString());
-        assertEquals("bar", entities.get(1).getSimpleString());
-        assertEquals("foo bar", entities.get(2).getSimpleString());
-
-        String[] values2 = {"bar"};
-        query.setParameters(simpleString, values2);
-        entities = query.find();
+        List<TestEntity> entities;
+        try (Query<TestEntity> query = box.query()
+                .in(simpleString, values, StringOrder.CASE_INSENSITIVE)
+                .order(simpleString, OrderFlags.CASE_SENSITIVE)
+                .build()) {
+            entities = query.find();
+            assertEquals(3, entities.size());
+            assertEquals("BAR", entities.get(0).getSimpleString());
+            assertEquals("bar", entities.get(1).getSimpleString());
+            assertEquals("foo bar", entities.get(2).getSimpleString());
+
+            String[] values2 = {"bar"};
+            query.setParameter(simpleString, values2);
+            entities = query.find();
+        }
         assertEquals(2, entities.size());
         assertEquals("BAR", entities.get(0).getSimpleString());
         assertEquals("bar", entities.get(1).getSimpleString());
 
         // Case sensitive
-        query = box.query().in(simpleString, values, StringOrder.CASE_SENSITIVE).order(simpleString).build();
-        entities = query.find();
+        try (Query<TestEntity> queryCaseSens = box.query()
+                .in(simpleString, values, StringOrder.CASE_SENSITIVE)
+                .order(simpleString)
+                .build()) {
+            entities = queryCaseSens.find();
+        }
         assertEquals(2, entities.size());
         assertEquals("bar", entities.get(0).getSimpleString());
         assertEquals("foo bar", entities.get(1).getSimpleString());
@@ -332,65 +702,166 @@ public void testByteArrayEqualsAndSetParameter() {
         putTestEntitiesScalars();
 
         byte[] value = {1, 2, (byte) 2000};
-        Query<TestEntity> query = box.query().equal(simpleByteArray, value).parameterAlias("bytes").build();
-
-        assertEquals(1, query.count());
-        TestEntity first = query.findFirst();
-        assertNotNull(first);
-        assertTrue(Arrays.equals(value, first.getSimpleByteArray()));
-
-        byte[] value2 = {1, 2, (byte) 2001};
-        query.setParameter(simpleByteArray, value2);
-
-        assertEquals(1, query.count());
-        TestEntity first2 = query.findFirst();
-        assertNotNull(first2);
-        assertTrue(Arrays.equals(value2, first2.getSimpleByteArray()));
-
-        byte[] value3 = {1, 2, (byte) 2002};
-        query.setParameter("bytes", value3);
-
-        assertEquals(1, query.count());
-        TestEntity first3 = query.findFirst();
-        assertNotNull(first3);
-        assertTrue(Arrays.equals(value3, first3.getSimpleByteArray()));
+        try (Query<TestEntity> query = box.query()
+                .equal(simpleByteArray, value)
+                .parameterAlias("bytes")
+                .build()) {
+            assertEquals(1, query.count());
+            TestEntity first = query.findFirst();
+            assertNotNull(first);
+            assertArrayEquals(value, first.getSimpleByteArray());
+
+            byte[] value2 = {1, 2, (byte) 2001};
+            query.setParameter(simpleByteArray, value2);
+
+            assertEquals(1, query.count());
+            TestEntity first2 = query.findFirst();
+            assertNotNull(first2);
+            assertArrayEquals(value2, first2.getSimpleByteArray());
+
+            byte[] value3 = {1, 2, (byte) 2002};
+            query.setParameter("bytes", value3);
+
+            assertEquals(1, query.count());
+            TestEntity first3 = query.findFirst();
+            assertNotNull(first3);
+            assertArrayEquals(value3, first3.getSimpleByteArray());
+        }
     }
 
     @Test
-    public void testByteArrayLess() {
+    public void byteArray_lessAndGreater_works() {
         putTestEntitiesScalars();
-
         byte[] value = {1, 2, (byte) 2005};
-        Query<TestEntity> query = box.query().less(simpleByteArray, value).build();
-        List<TestEntity> results = query.find();
 
-        assertEquals(5, results.size());
-        // Java does not have compareTo for arrays, so just make sure its not equal to the value
-        for (TestEntity result : results) {
-            assertFalse(Arrays.equals(value, result.getSimpleByteArray()));
-        }
+        // Java does not have compareTo for arrays, so just make sure it's not equal to the value.
+        ListItemAsserter<TestEntity> resultsNotEqual = (index, item) -> assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleByteArray, value), 5, resultsNotEqual
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleByteArray, value), 4, resultsNotEqual
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleByteArray, value),
+                6,
+                (index, item) -> {
+                    if (index == 5) {
+                        assertArrayEquals(value, item.getSimpleByteArray());
+                    } else {
+                        assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+                    }
+                }
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleByteArray, value),
+                5,
+                (index, item) -> {
+                    if (index == 0) {
+                        assertArrayEquals(value, item.getSimpleByteArray());
+                    } else {
+                        assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+                    }
+                }
+        );
+
+        // greater and less
+        byte[] valueGreater = {1, 2, (byte) 2002};
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleByteArray, valueGreater).less(TestEntity_.simpleByteArray, value),
+                2,
+                (index, item) -> {
+                    assertFalse(Arrays.equals(value, item.getSimpleByteArray()));
+                    assertFalse(Arrays.equals(valueGreater, item.getSimpleByteArray()));
+                }
+        );
     }
 
     @Test
-    public void testByteArrayGreater() {
+    public void float_lessAndGreater_works() {
         putTestEntitiesScalars();
-
-        byte[] value = {1, 2, (byte) 2005};
-        Query<TestEntity> query = box.query().greater(simpleByteArray, value).build();
-        List<TestEntity> results = query.find();
-
-        assertEquals(4, results.size());
-        // Java does not have compareTo for arrays, so just make sure its not equal to the value
-        for (TestEntity result : results) {
-            assertFalse(Arrays.equals(value, result.getSimpleByteArray()));
-        }
+        float value = 400.5f;
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleFloat, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleFloat() < value)
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleFloat, value),
+                6,
+                (index, item) -> assertTrue(item.getSimpleFloat() <= value)
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleFloat, value),
+                4,
+                (index, item) -> assertTrue(item.getSimpleFloat() > value)
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleFloat, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleFloat() >= value)
+        );
+
+        float valueLess = 400.51f;
+        float valueGreater = 400.29f;
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleFloat, valueGreater).less(TestEntity_.simpleFloat, valueLess),
+                3,
+                (index, item) -> {
+                    assertTrue(item.getSimpleFloat() < valueLess);
+                    assertTrue(item.getSimpleFloat() > valueGreater);
+                }
+        );
     }
 
     @Test
-    public void testScalarFloatLessAndGreater() {
+    public void double_lessAndGreater_works() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().greater(simpleFloat, 400.29f).less(simpleFloat, 400.51f).build();
-        assertEquals(3, query.count());
+        // Note: calculation matches putTestEntitiesScalars.
+        double value = 2000 + 2005 / 100f;
+
+        buildFindAndAssert(
+                box.query().less(TestEntity_.simpleDouble, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleDouble() < value)
+        );
+
+        buildFindAndAssert(
+                box.query().lessOrEqual(TestEntity_.simpleDouble, value),
+                6,
+                (index, item) -> assertTrue(item.getSimpleDouble() <= value)
+        );
+
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleDouble, value),
+                4,
+                (index, item) -> assertTrue(item.getSimpleDouble() > value)
+        );
+
+        buildFindAndAssert(
+                box.query().greaterOrEqual(TestEntity_.simpleDouble, value),
+                5,
+                (index, item) -> assertTrue(item.getSimpleDouble() >= value)
+        );
+
+        double valueLess = 2020.051;
+        double valueGreater = 2020.029;
+        buildFindAndAssert(
+                box.query().greater(TestEntity_.simpleDouble, valueGreater).less(TestEntity_.simpleDouble, valueLess),
+                3,
+                (index, item) -> {
+                    assertTrue(item.getSimpleDouble() < valueLess);
+                    assertTrue(item.getSimpleDouble() > valueGreater);
+                }
+        );
     }
 
     @Test
@@ -405,30 +876,44 @@ public void testBigResultList() {
         }
         box.put(entities);
         int count = entities.size();
-        List<TestEntity> entitiesQueried = box.query().equal(simpleString, sameValueForAll).build().find();
-        assertEquals(count, entitiesQueried.size());
+        try (Query<TestEntity> query = box.query()
+                .equal(simpleString, sameValueForAll, StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            List<TestEntity> entitiesQueried = query.find();
+            assertEquals(count, entitiesQueried.size());
+        }
     }
 
     @Test
     public void testEqualStringOrder() {
         putTestEntitiesStrings();
         putTestEntity("BAR", 100);
-        assertEquals(2, box.query().equal(simpleString, "bar").build().count());
-        assertEquals(1, box.query().equal(simpleString, "bar", StringOrder.CASE_SENSITIVE).build().count());
+        try (Query<TestEntity> queryInSens = box.query()
+                .equal(simpleString, "bar", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            assertEquals(2, queryInSens.count());
+        }
+        try (Query<TestEntity> querySens = box.query()
+                .equal(simpleString, "bar", StringOrder.CASE_SENSITIVE)
+                .build()) {
+            assertEquals(1, querySens.count());
+        }
     }
 
     @Test
     public void testOrder() {
         putTestEntitiesStrings();
         putTestEntity("BAR", 100);
-        List<TestEntity> result = box.query().order(simpleString).build().find();
-        assertEquals(6, result.size());
-        assertEquals("apple", result.get(0).getSimpleString());
-        assertEquals("banana", result.get(1).getSimpleString());
-        assertEquals("banana milk shake", result.get(2).getSimpleString());
-        assertEquals("bar", result.get(3).getSimpleString());
-        assertEquals("BAR", result.get(4).getSimpleString());
-        assertEquals("foo bar", result.get(5).getSimpleString());
+        try (Query<TestEntity> query = box.query().order(simpleString).build()) {
+            List<TestEntity> result = query.find();
+            assertEquals(6, result.size());
+            assertEquals("apple", result.get(0).getSimpleString());
+            assertEquals("banana", result.get(1).getSimpleString());
+            assertEquals("banana milk shake", result.get(2).getSimpleString());
+            assertEquals("bar", result.get(3).getSimpleString());
+            assertEquals("BAR", result.get(4).getSimpleString());
+            assertEquals("foo bar", result.get(5).getSimpleString());
+        }
     }
 
     @Test
@@ -437,48 +922,85 @@ public void testOrderDescCaseNullLast() {
         putTestEntity("BAR", 100);
         putTestEntitiesStrings();
         int flags = QueryBuilder.CASE_SENSITIVE | QueryBuilder.NULLS_LAST | QueryBuilder.DESCENDING;
-        List<TestEntity> result = box.query().order(simpleString, flags).build().find();
-        assertEquals(7, result.size());
-        assertEquals("foo bar", result.get(0).getSimpleString());
-        assertEquals("bar", result.get(1).getSimpleString());
-        assertEquals("banana milk shake", result.get(2).getSimpleString());
-        assertEquals("banana", result.get(3).getSimpleString());
-        assertEquals("apple", result.get(4).getSimpleString());
-        assertEquals("BAR", result.get(5).getSimpleString());
-        assertNull(result.get(6).getSimpleString());
+        try (Query<TestEntity> query = box.query().order(simpleString, flags).build()) {
+            List<TestEntity> result = query.find();
+            assertEquals(7, result.size());
+            assertEquals("foo bar", result.get(0).getSimpleString());
+            assertEquals("bar", result.get(1).getSimpleString());
+            assertEquals("banana milk shake", result.get(2).getSimpleString());
+            assertEquals("banana", result.get(3).getSimpleString());
+            assertEquals("apple", result.get(4).getSimpleString());
+            assertEquals("BAR", result.get(5).getSimpleString());
+            assertNull(result.get(6).getSimpleString());
+        }
     }
 
     @Test
     public void testRemove() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().greater(simpleInt, 2003).build();
-        assertEquals(6, query.remove());
+        try (Query<TestEntity> query = box.query().greater(simpleInt, 2003).build()) {
+            assertEquals(6, query.remove());
+        }
         assertEquals(4, box.count());
     }
 
+    @Test
+    public void findFirstId() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(simpleInt.greater(2006)).build()) {
+            assertEquals(8, query.findFirstId());
+        }
+        // No result.
+        try (Query<TestEntity> query = box.query(simpleInt.equal(-1)).build()) {
+            assertEquals(0, query.findFirstId());
+        }
+    }
+
+    @Test
+    public void findUniqueId() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(simpleInt.equal(2006)).build()) {
+            assertEquals(7, query.findUniqueId());
+        }
+        // No result.
+        try (Query<TestEntity> query = box.query(simpleInt.equal(-1)).build()) {
+            assertEquals(0, query.findUniqueId());
+        }
+        // More than one result.
+        try (Query<TestEntity> query = box.query(simpleInt.greater(2006)).build()) {
+            NonUniqueResultException e = assertThrows(NonUniqueResultException.class, query::findUniqueId);
+            assertEquals("Query does not have a unique result (more than one result): 3", e.getMessage());
+        }
+    }
+
     @Test
     public void testFindIds() {
         putTestEntitiesScalars();
-        assertEquals(10, box.query().build().findIds().length);
+        try (Query<TestEntity> queryAll = box.query().build()) {
+            assertEquals(10, queryAll.findIds().length);
+        }
 
-        Query<TestEntity> query = box.query().greater(simpleInt, 2006).build();
-        long[] keys = query.findIds();
-        assertEquals(3, keys.length);
-        assertEquals(8, keys[0]);
-        assertEquals(9, keys[1]);
-        assertEquals(10, keys[2]);
+        try (Query<TestEntity> query = box.query().greater(simpleInt, 2006).build()) {
+            long[] keys = query.findIds();
+            assertEquals(3, keys.length);
+            assertEquals(8, keys[0]);
+            assertEquals(9, keys[1]);
+            assertEquals(10, keys[2]);
+        }
     }
 
     @Test
     public void testFindIdsWithOrder() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().orderDesc(TestEntity_.simpleInt).build();
-        long[] ids = query.findIds();
-        assertEquals(10, ids.length);
-        assertEquals(10, ids[0]);
-        assertEquals(1, ids[9]);
-
-        ids = query.findIds(3, 2);
+        long[] ids;
+        try (Query<TestEntity> query = box.query().orderDesc(TestEntity_.simpleInt).build()) {
+            ids = query.findIds();
+            assertEquals(10, ids.length);
+            assertEquals(10, ids[0]);
+            assertEquals(1, ids[9]);
+
+            ids = query.findIds(3, 2);
+        }
         assertEquals(2, ids.length);
         assertEquals(7, ids[0]);
         assertEquals(6, ids[1]);
@@ -487,51 +1009,93 @@ public void testFindIdsWithOrder() {
     @Test
     public void testOr() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().equal(simpleInt, 2007).or().equal(simpleLong, 3002).build();
-        List<TestEntity> entities = query.find();
+        List<TestEntity> entities;
+        try (Query<TestEntity> query = box.query()
+                .equal(simpleInt, 2007)
+                .or().equal(simpleLong, 3002)
+                .build()) {
+            entities = query.find();
+        }
         assertEquals(2, entities.size());
         assertEquals(3002, entities.get(0).getSimpleLong());
         assertEquals(2007, entities.get(1).getSimpleInt());
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testOr_bad1() {
-        box.query().or();
+        assertNoPreviousCondition(() -> box.query().or());
     }
 
-    @Test(expected = IllegalStateException.class)
+    private void assertNoPreviousCondition(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("No previous condition. Use operators like and() and or() only between two conditions.",
+                ex.getMessage());
+    }
+
+    @SuppressWarnings("resource") // Throws RuntimeException, so not closing Builder/Query is fine.
+    @Test
     public void testOr_bad2() {
-        box.query().equal(simpleInt, 1).or().build();
+        assertIncompleteLogicCondition(() -> box.query().equal(simpleInt, 1).or().build());
+    }
+
+    private void assertIncompleteLogicCondition(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("Incomplete logic condition. Use or()/and() between two conditions only.",
+                ex.getMessage());
     }
 
     @Test
     public void testAnd() {
         putTestEntitiesScalars();
-        // OR precedence (wrong): {}, AND precedence (expected): 2008
-        Query<TestEntity> query = box.query().equal(simpleInt, 2006).and().equal(simpleInt, 2007).or().equal(simpleInt, 2008).build();
-        List<TestEntity> entities = query.find();
+        // Result if OR precedence (wrong): {}, AND precedence (expected): {2008}
+        List<TestEntity> entities;
+        try (Query<TestEntity> query = box.query()
+                .equal(simpleInt, 2006)
+                .and().equal(simpleInt, 2007)
+                .or().equal(simpleInt, 2008)
+                .build()) {
+            entities = query.find();
+        }
         assertEquals(1, entities.size());
         assertEquals(2008, entities.get(0).getSimpleInt());
     }
 
-    @Test(expected = IllegalStateException.class)
+    @Test
     public void testAnd_bad1() {
-        box.query().and();
+        assertNoPreviousCondition(() -> box.query().and());
     }
 
-    @Test(expected = IllegalStateException.class)
+    @SuppressWarnings("resource") // Throws RuntimeException, so not closing Builder/Query is fine.
+    @Test
     public void testAnd_bad2() {
-        box.query().equal(simpleInt, 1).and().build();
+        assertIncompleteLogicCondition(() -> box.query().equal(simpleInt, 1).and().build());
     }
 
-    @Test(expected = IllegalStateException.class)
+    @SuppressWarnings("resource") // Throws RuntimeException, so not closing Builder/Query is fine.
+    @Test
     public void testOrAfterAnd() {
-        box.query().equal(simpleInt, 1).and().or().equal(simpleInt, 2).build();
+        assertOperatorIsPending(() -> box.query()
+                .equal(simpleInt, 1)
+                .and()
+                .or()
+                .equal(simpleInt, 2)
+                .build());
     }
 
-    @Test(expected = IllegalStateException.class)
+    @SuppressWarnings("resource") // Throws RuntimeException, so not closing Builder/Query is fine.
+    @Test
     public void testOrderAfterAnd() {
-        box.query().equal(simpleInt, 1).and().order(simpleInt).equal(simpleInt, 2).build();
+        assertOperatorIsPending(() -> box.query()
+                .equal(simpleInt, 1)
+                .and().order(simpleInt)
+                .equal(simpleInt, 2)
+                .build());
+    }
+
+    private void assertOperatorIsPending(ThrowingRunnable runnable) {
+        IllegalStateException ex = assertThrows(IllegalStateException.class, runnable);
+        assertEquals("Another operator is pending. Use operators like and() and or() only between two conditions.",
+                ex.getMessage());
     }
 
     @Test
@@ -542,98 +1106,122 @@ public void testSetParameterInt() {
         assertTrue(versionStart, versionStart.compareTo(minVersion) >= 0);
 
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().equal(simpleInt, 2007).parameterAlias("foo").build();
-        assertEquals(8, query.findUnique().getId());
-        query.setParameter(simpleInt, 2004);
-        assertEquals(5, query.findUnique().getId());
-
-        query.setParameter("foo", 2002);
-        assertEquals(3, query.findUnique().getId());
+        try (Query<TestEntity> query = box.query()
+                .equal(simpleInt, 2007)
+                .parameterAlias("foo")
+                .build()) {
+            assertEquals(8, getUniqueNotNull(query).getId());
+            query.setParameter(simpleInt, 2004);
+            assertEquals(5, getUniqueNotNull(query).getId());
+
+            query.setParameter("foo", 2002);
+            assertEquals(3, getUniqueNotNull(query).getId());
+        }
     }
 
     @Test
     public void testSetParameter2Ints() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().between(simpleInt, 2005, 2008).parameterAlias("foo").build();
-        assertEquals(4, query.count());
-        query.setParameters(simpleInt, 2002, 2003);
-        List<TestEntity> entities = query.find();
-        assertEquals(2, entities.size());
-        assertEquals(3, entities.get(0).getId());
-        assertEquals(4, entities.get(1).getId());
-
-        query.setParameters("foo", 2007, 2007);
-        assertEquals(8, query.findUnique().getId());
+        try (Query<TestEntity> query = box.query()
+                .between(simpleInt, 2005, 2008)
+                .parameterAlias("foo")
+                .build()) {
+            assertEquals(4, query.count());
+            query.setParameters(simpleInt, 2002, 2003);
+            List<TestEntity> entities = query.find();
+            assertEquals(2, entities.size());
+            assertEquals(3, entities.get(0).getId());
+            assertEquals(4, entities.get(1).getId());
+
+            query.setParameters("foo", 2007, 2007);
+            assertEquals(8, getUniqueNotNull(query).getId());
+        }
     }
 
     @Test
     public void testSetParameterFloat() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().greater(simpleFloat, 400.65).parameterAlias("foo").build();
-        assertEquals(3, query.count());
-        query.setParameter(simpleFloat, 400.75);
-        assertEquals(2, query.count());
-
-        query.setParameter("foo", 400.85);
-        assertEquals(1, query.count());
+        try (Query<TestEntity> query = box.query()
+                .greater(simpleFloat, 400.65)
+                .parameterAlias("foo")
+                .build()) {
+            assertEquals(3, query.count());
+            query.setParameter(simpleFloat, 400.75);
+            assertEquals(2, query.count());
+
+            query.setParameter("foo", 400.85);
+            assertEquals(1, query.count());
+        }
     }
 
     @Test
     public void testSetParameter2Floats() {
         putTestEntitiesScalars();
-        Query<TestEntity> query = box.query().between(simpleFloat, 400.15, 400.75).parameterAlias("foo").build();
-        assertEquals(6, query.count());
-        query.setParameters(simpleFloat, 400.65, 400.85);
-        List<TestEntity> entities = query.find();
-        assertEquals(2, entities.size());
-        assertEquals(8, entities.get(0).getId());
-        assertEquals(9, entities.get(1).getId());
-
-        query.setParameters("foo", 400.45, 400.55);
-        assertEquals(6, query.findUnique().getId());
+        try (Query<TestEntity> query = box.query()
+                .between(simpleFloat, 400.15, 400.75)
+                .parameterAlias("foo")
+                .build()) {
+            assertEquals(6, query.count());
+            query.setParameters(simpleFloat, 400.65, 400.85);
+            List<TestEntity> entities = query.find();
+            assertEquals(2, entities.size());
+            assertEquals(8, entities.get(0).getId());
+            assertEquals(9, entities.get(1).getId());
+
+            query.setParameters("foo", 400.45, 400.55);
+            assertEquals(6, getUniqueNotNull(query).getId());
+        }
     }
 
     @Test
     public void testSetParameterString() {
         putTestEntitiesStrings();
-        Query<TestEntity> query = box.query().equal(simpleString, "banana").parameterAlias("foo").build();
-        assertEquals(1, query.findUnique().getId());
-        query.setParameter(simpleString, "bar");
-        assertEquals(3, query.findUnique().getId());
-
-        assertNull(query.setParameter(simpleString, "not here!").findUnique());
-
-        query.setParameter("foo", "apple");
-        assertEquals(2, query.findUnique().getId());
+        try (Query<TestEntity> query = box.query()
+                .equal(simpleString, "banana", StringOrder.CASE_INSENSITIVE)
+                .parameterAlias("foo")
+                .build()) {
+            assertEquals(1, getUniqueNotNull(query).getId());
+            query.setParameter(simpleString, "bar");
+            assertEquals(3, getUniqueNotNull(query).getId());
+
+            assertNull(query.setParameter(simpleString, "not here!").findUnique());
+
+            query.setParameter("foo", "apple");
+            assertEquals(2, getUniqueNotNull(query).getId());
+        }
     }
 
     /**
-     * https://github.com/objectbox/objectbox-java/issues/834
+     * <a href="https://github.com/objectbox/objectbox-java/issues/834">Using alias on condition combined with AND or OR fails #834</a>
      */
     @Test
     public void parameterAlias_combinedConditions() {
         putTestEntitiesScalars();
 
-        Query<TestEntity> query = box.query()
+        try (Query<TestEntity> query = box.query()
                 .greater(simpleInt, 0).parameterAlias("greater")
                 .or()
                 .less(simpleInt, 0).parameterAlias("less")
-                .build();
-        List<TestEntity> results = query
-                .setParameter("greater", 2008)
-                .setParameter("less", 2001)
-                .find();
-        assertEquals(2, results.size());
-        assertEquals(2000, results.get(0).getSimpleInt());
-        assertEquals(2009, results.get(1).getSimpleInt());
+                .build()) {
+            List<TestEntity> results = query
+                    .setParameter("greater", 2008)
+                    .setParameter("less", 2001)
+                    .find();
+            assertEquals(2, results.size());
+            assertEquals(2000, results.get(0).getSimpleInt());
+            assertEquals(2009, results.get(1).getSimpleInt());
+        }
     }
 
     @Test
     public void testForEach() {
         List<TestEntity> testEntities = putTestEntitiesStrings();
         final StringBuilder stringBuilder = new StringBuilder();
-        box.query().startsWith(simpleString, "banana").build()
-                .forEach(data -> stringBuilder.append(data.getSimpleString()).append('#'));
+        try (Query<TestEntity> query = box.query()
+                .startsWith(simpleString, "banana", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            query.forEach(data -> stringBuilder.append(data.getSimpleString()).append('#'));
+        }
         assertEquals("banana#banana milk shake#", stringBuilder.toString());
 
         // Verify that box does not hang on to the read-only TX by doing a put
@@ -645,11 +1233,14 @@ public void testForEach() {
     public void testForEachBreak() {
         putTestEntitiesStrings();
         final StringBuilder stringBuilder = new StringBuilder();
-        box.query().startsWith(simpleString, "banana").build()
-                .forEach(data -> {
-                    stringBuilder.append(data.getSimpleString());
-                    throw new BreakForEach();
-                });
+        try (Query<TestEntity> query = box.query()
+                .startsWith(simpleString, "banana", StringOrder.CASE_INSENSITIVE)
+                .build()) {
+            query.forEach(data -> {
+                stringBuilder.append(data.getSimpleString());
+                throw new BreakForEach();
+            });
+        }
         assertEquals("banana", stringBuilder.toString());
     }
 
@@ -657,34 +1248,101 @@ public void testForEachBreak() {
     // TODO can we improve? More than just "still works"?
     public void testQueryAttempts() {
         store.close();
-        BoxStoreBuilder builder = new BoxStoreBuilder(createTestModel(false)).directory(boxStoreDir)
+        BoxStoreBuilder builder = createBuilderWithTestModel().directory(boxStoreDir)
                 .queryAttempts(5)
-                .failedReadTxAttemptCallback((result, error) -> error.printStackTrace());
+                .failedReadTxAttemptCallback((result, error) -> {
+                    if (error != null) {
+                        error.printStackTrace();
+                    }
+                });
         builder.entity(new TestEntity_());
 
         store = builder.build();
         putTestEntitiesScalars();
 
         Query<TestEntity> query = store.boxFor(TestEntity.class).query().equal(simpleInt, 2007).build();
-        assertEquals(2007, query.findFirst().getSimpleInt());
+        assertEquals(2007, getFirstNotNull(query).getSimpleInt());
     }
 
     @Test
-    public void testDateParam() {
-        store.close();
-        assertTrue(store.deleteAllFiles());
-        store = MyObjectBox.builder().baseDirectory(boxStoreDir).debugFlags(DebugFlags.LOG_QUERY_PARAMETERS).build();
-
+    public void date_equal_and_setParameter_works() {
         Date now = new Date();
-        Order order = new Order();
-        order.setDate(now);
-        Box<Order> box = store.boxFor(Order.class);
-        box.put(order);
+        TestEntity entity = new TestEntity();
+        entity.setDate(now);
+        Box<TestEntity> box = store.boxFor(TestEntity.class);
+        box.put(entity);
+
+        try (Query<TestEntity> query = box.query(TestEntity_.date.equal(0)).build()) {
+            assertEquals(0, query.count());
+            query.setParameter(TestEntity_.date, now);
+            assertEquals(1, query.count());
+        }
 
-        Query<Order> query = box.query().equal(Order_.date, 0).build();
-        assertEquals(0, query.count());
+        // Again, but using alias
+        try (Query<TestEntity> aliasQuery = box.query(TestEntity_.date.equal(0)).parameterAlias("date").build()) {
+            assertEquals(0, aliasQuery.count());
+            aliasQuery.setParameter("date", now);
+            assertEquals(1, aliasQuery.count());
+        }
+    }
+
+    @Test
+    public void date_between_works() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(date.between(new Date(3002L), new Date(3008L))).build()) {
+            assertEquals(7, query.count());
+        }
+    }
+
+    @Test
+    public void date_lessAndGreater_works() {
+        putTestEntitiesScalars();
+        try (Query<TestEntity> query = box.query(date.less(new Date(3002L))).build()) {
+            assertEquals(2, query.count());
+        }
+        try (Query<TestEntity> query = box.query(date.lessOrEqual(new Date(3003L))).build()) {
+            assertEquals(4, query.count());
+        }
+        try (Query<TestEntity> query = box.query(date.greater(new Date(3008L))).build()) {
+            assertEquals(1, query.count());
+        }
+        try (Query<TestEntity> query = box.query(date.greaterOrEqual(new Date(3008L))).build()) {
+            assertEquals(2, query.count());
+        }
+    }
+
+    @Test
+    public void date_oneOf_works() {
+        putTestEntitiesScalars();
+        Date[] valuesDate = new Date[]{new Date(3002L), new Date(), new Date(0)};
+        try (Query<TestEntity> query = box.query(date.oneOf(valuesDate)).build()) {
+            assertEquals(1, query.count());
+        }
+        Date[] valuesDate2 = new Date[]{new Date()};
+        try (Query<TestEntity> query = box.query(date.oneOf(valuesDate2)).build()) {
+            assertEquals(0, query.count());
+        }
+        Date[] valuesDate3 = new Date[]{new Date(3002L), new Date(3009L)};
+        try (Query<TestEntity> query = box.query(date.oneOf(valuesDate3)).build()) {
+            assertEquals(2, query.count());
+        }
+    }
 
-        query.setParameter(Order_.date, now);
+    @Test
+    public void date_notOneOf_works() {
+        putTestEntitiesScalars();
+        Date[] valuesDate = new Date[]{new Date(3002L), new Date(), new Date(0)};
+        try (Query<TestEntity> query = box.query(date.notOneOf(valuesDate)).build()) {
+            assertEquals(9, query.count());
+        }
+        Date[] valuesDate2 = new Date[]{new Date()};
+        try (Query<TestEntity> query = box.query(date.notOneOf(valuesDate2)).build()) {
+            assertEquals(10, query.count());
+        }
+        Date[] valuesDate3 = new Date[]{new Date(3002L), new Date(3009L)};
+        try (Query<TestEntity> query = box.query(date.notOneOf(valuesDate3)).build()) {
+            assertEquals(8, query.count());
+        }
     }
 
     @Test
@@ -692,14 +1350,33 @@ public void testFailedUnique_exceptionListener() {
         final Exception[] exs = {null};
         DbExceptionListener exceptionListener = e -> exs[0] = e;
         putTestEntitiesStrings();
-        Query<TestEntity> query = box.query().build();
-        store.setDbExceptionListener(exceptionListener);
-        try {
-            query.findUnique();
-            fail("Should have thrown");
-        } catch (NonUniqueResultException e) {
-            assertSame(e, exs[0]);
+        try (Query<TestEntity> query = box.query().build()) {
+            store.setDbExceptionListener(exceptionListener);
+            try {
+                query.findUnique();
+                fail("Should have thrown");
+            } catch (NonUniqueResultException e) {
+                assertSame(e, exs[0]);
+            }
+        }
+    }
+
+    @Test
+    public void testFailedUnique_cancelException() {
+        final Exception[] exs = {null};
+        DbExceptionListener exceptionListener = e -> {
+            if (exs[0] != null) throw new RuntimeException("Called more than once");
+            exs[0] = e;
+            DbExceptionListener.cancelCurrentException();
+        };
+        putTestEntitiesStrings();
+        try (Query<TestEntity> query = box.query().build()) {
+            store.setDbExceptionListener(exceptionListener);
+            TestEntity object = query.findUnique();
+            assertNull(object);
         }
+        assertNotNull(exs[0]);
+        assertEquals(exs[0].getClass(), NonUniqueResultException.class);
     }
 
     @Test
@@ -707,20 +1384,48 @@ public void testDescribe() {
         // Note: description string correctness is fully asserted in core library.
 
         // No conditions.
-        Query<TestEntity> queryNoConditions = box.query().build();
-        assertEquals("Query for entity TestEntity with 1 conditions",queryNoConditions.describe());
-        assertEquals("TRUE", queryNoConditions.describeParameters());
+        try (Query<TestEntity> queryNoConditions = box.query().build()) {
+            assertEquals("Query for entity TestEntity with 1 conditions", queryNoConditions.describe());
+            assertEquals("TRUE", queryNoConditions.describeParameters());
+        }
 
         // Some conditions.
-        Query<TestEntity> query = box.query()
-                .equal(TestEntity_.simpleString, "Hello")
+        try (Query<TestEntity> query = box.query()
+                .equal(TestEntity_.simpleString, "Hello", StringOrder.CASE_INSENSITIVE)
                 .or().greater(TestEntity_.simpleInt, 42)
-                .build();
-        String describeActual = query.describe();
-        assertTrue(describeActual.startsWith("Query for entity TestEntity with 3 conditions with properties "));
-        // Note: the order properties are listed in is not fixed.
-        assertTrue(describeActual.contains(TestEntity_.simpleString.name));
-        assertTrue(describeActual.contains(TestEntity_.simpleInt.name));
-        assertEquals("(simpleString ==(i) \"Hello\"\n OR simpleInt > 42)", query.describeParameters());
+                .build()) {
+            String describeActual = query.describe();
+            assertTrue(describeActual.startsWith("Query for entity TestEntity with 3 conditions with properties "));
+            // Note: the order properties are listed in is not fixed.
+            assertTrue(describeActual.contains(TestEntity_.simpleString.name));
+            assertTrue(describeActual.contains(TestEntity_.simpleInt.name));
+            assertEquals("(simpleString ==(i) \"Hello\"\n OR simpleInt > 42)", query.describeParameters());
+        }
+    }
+
+    private <T> void buildFindAndAssert(QueryBuilder<T> builder, int expectedCount, ListItemAsserter<T> asserter) {
+        try (Query<T> query = builder.build()) {
+            List<T> results = query.find();
+            assertEquals(expectedCount, results.size());
+            for (int i = 0; i < results.size(); i++) {
+                asserter.assertListItem(i, results.get(i));
+            }
+        }
+    }
+
+    private interface ListItemAsserter<T> {
+        void assertListItem(int index, T item);
+    }
+
+    private <T> T getFirstNotNull(Query<T> query) {
+        T first = query.findFirst();
+        assertNotNull(first);
+        return first;
+    }
+
+    private <T> T getUniqueNotNull(Query<T> query) {
+        T first = query.findUnique();
+        assertNotNull(first);
+        return first;
     }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java
new file mode 100644
index 00000000..9a9b9260
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTest2.java
@@ -0,0 +1,176 @@
+/*
+ * Copyright 2017 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query;
+
+import io.objectbox.query.QueryBuilder.StringOrder;
+import org.junit.Test;
+
+import java.util.List;
+
+import io.objectbox.TestEntity;
+import io.objectbox.TestEntity_;
+
+
+import static io.objectbox.TestEntity_.simpleInt;
+import static io.objectbox.TestEntity_.simpleLong;
+import static org.junit.Assert.assertEquals;
+
+/**
+ * Tests {@link Query} using the new query builder API with nesting support.
+ */
+public class QueryTest2 extends AbstractQueryTest {
+
+    @Test
+    public void newQueryApi() {
+        putTestEntity("Fry", 14);
+        putTestEntity("Fry", 12);
+        putTestEntity("Fry", 10);
+
+        // current query API
+        Query<TestEntity> query = box.query()
+                .equal(TestEntity_.simpleString, "Fry", StringOrder.CASE_INSENSITIVE)
+                .less(TestEntity_.simpleInt, 12)
+                .or()
+                .in(TestEntity_.simpleLong, new long[]{1012})
+                .order(TestEntity_.simpleInt)
+                .build();
+
+        List<TestEntity> results = query.find();
+        assertEquals(2, results.size());
+        assertEquals(10, results.get(0).getSimpleInt());
+        assertEquals(12, results.get(1).getSimpleInt());
+
+        // suggested query API
+        Query<TestEntity> newQuery = box.query(
+                TestEntity_.simpleString.equal("Fry")
+                        .and(TestEntity_.simpleInt.less(12)
+                                .or(TestEntity_.simpleLong.oneOf(new long[]{1012}))))
+                .order(TestEntity_.simpleInt)
+                .build();
+
+        List<TestEntity> newResults = newQuery.find();
+        assertEquals(2, newResults.size());
+        assertEquals(10, newResults.get(0).getSimpleInt());
+        assertEquals(12, newResults.get(1).getSimpleInt());
+    }
+
+    /**
+     * Combining conditions using and(cond) and or(cond) implicitly adds parentheses.
+     */
+    @Test
+    public void combiningAddsImplicitParentheses() {
+        putTestEntity("Fry", 14);
+        putTestEntity("Fry", 12);
+        putTestEntity("Fry", 10);
+
+        // Nested OR
+        // (Sarah OR Fry) AND <12
+        List<TestEntity> resultsOr = box.query(
+                TestEntity_.simpleString.equal("Sarah")
+                        .or(
+                                TestEntity_.simpleString.equal("Fry")
+                        )
+                        .and(
+                                TestEntity_.simpleInt.less(12)
+                        )
+        ).build().find();
+        // <12 AND (Fry OR Sarah)
+        List<TestEntity> resultsNestedOr = box.query(
+                TestEntity_.simpleInt.less(12)
+                        .and(
+                                TestEntity_.simpleString.equal("Fry")
+                                        .or(
+                                                TestEntity_.simpleString.equal("Sarah")
+                                        )
+                        )
+        ).build().find();
+        // Only the Fry age 10.
+        assertEquals(1, resultsOr.size());
+        assertEquals(1, resultsNestedOr.size());
+        assertEquals(10, resultsOr.get(0).getSimpleInt());
+        assertEquals(10, resultsNestedOr.get(0).getSimpleInt());
+
+        // Nested AND
+        // (<12 AND Sarah) OR Fry
+        List<TestEntity> resultsAnd = box.query(
+                TestEntity_.simpleInt.less(12)
+                        .and(
+                                TestEntity_.simpleString.equal("Sarah")
+                        )
+                        .or(
+                                TestEntity_.simpleString.equal("Fry")
+                        )
+        ).build().find();
+        // Fry OR (Sarah AND <12)
+        List<TestEntity> resultsNestedAnd = box.query(
+                TestEntity_.simpleString.equal("Fry")
+                        .or(
+                                TestEntity_.simpleString.equal("Sarah")
+                                        .and(
+                                                TestEntity_.simpleInt.less(12)
+                                        )
+                        )
+        ).build().find();
+        // All three Fry's.
+        assertEquals(3, resultsAnd.size());
+        assertEquals(3, resultsNestedAnd.size());
+    }
+
+    @Test
+    public void or() {
+        putTestEntitiesScalars();
+        Query<TestEntity> query = box.query(simpleInt.equal(2007).or(simpleLong.equal(3002))).build();
+        List<TestEntity> entities = query.find();
+        assertEquals(2, entities.size());
+        assertEquals(3002, entities.get(0).getSimpleLong());
+        assertEquals(2007, entities.get(1).getSimpleInt());
+    }
+
+    @Test
+    public void and() {
+        putTestEntitiesScalars();
+        // Result if OR precedence (wrong): {}, AND precedence (expected): {2008}
+        Query<TestEntity> query = box.query(TestEntity_.simpleInt.equal(2006)
+                .and(TestEntity_.simpleInt.equal(2007))
+                .or(TestEntity_.simpleInt.equal(2008)))
+                .build();
+        List<TestEntity> entities = query.find();
+        assertEquals(1, entities.size());
+        assertEquals(2008, entities.get(0).getSimpleInt());
+    }
+
+    /**
+     * https://github.com/objectbox/objectbox-java/issues/834
+     */
+    @Test
+    public void parameterAlias_combineWithOr() {
+        putTestEntitiesScalars();
+
+        Query<TestEntity> query = box.query(
+                simpleInt.greater(0).alias("greater")
+                        .or(simpleInt.less(0).alias("less"))
+        ).order(simpleInt).build();
+        List<TestEntity> results = query
+                .setParameter("greater", 2008)
+                .setParameter("less", 2001)
+                .find();
+        assertEquals(2, results.size());
+        assertEquals(2000, results.get(0).getSimpleInt());
+        assertEquals(2009, results.get(1).getSimpleInt());
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt
new file mode 100644
index 00000000..47867956
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/query/QueryTestK.kt
@@ -0,0 +1,154 @@
+/*
+ * Copyright 2020-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.query
+
+import io.objectbox.TestEntity_
+import io.objectbox.kotlin.*
+import io.objectbox.query.QueryBuilder.StringOrder
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Tests Kotlin extension functions syntax for queries works as expected.
+ */
+class QueryTestK : AbstractQueryTest() {
+
+    @Test
+    fun queryBlock_and_inValues() {
+        putTestEntitiesScalars()
+        val valuesLong = longArrayOf(3000)
+
+        val resultJava = box.query().`in`(TestEntity_.simpleLong, valuesLong).build().use {
+            it.findFirst()
+        }
+        // Keep testing the old query API on purpose
+        @Suppress("DEPRECATION") val result = box.query {
+            inValues(TestEntity_.simpleLong, valuesLong)
+        }.use {
+            it.findFirst()
+        }
+        assertEquals(resultJava!!.id, result!!.id)
+    }
+
+    @Test
+    fun newQueryApi() {
+        putTestEntity("Fry", 14)
+        putTestEntity("Fry", 12)
+        putTestEntity("Fry", 10)
+
+        // Old query API
+        @Suppress("DEPRECATION") val query = box.query {
+            less(TestEntity_.simpleInt, 12)
+            or()
+            inValues(TestEntity_.simpleLong, longArrayOf(1012))
+            equal(TestEntity_.simpleString, "Fry", StringOrder.CASE_INSENSITIVE)
+            order(TestEntity_.simpleInt)
+        }
+        val results = query.find()
+        assertEquals(2, results.size)
+        assertEquals(10, results[0].simpleInt)
+        assertEquals(12, results[1].simpleInt)
+
+        // New query API
+        val newQuery = box.query(
+                (TestEntity_.simpleInt less 12 or (TestEntity_.simpleLong oneOf longArrayOf(1012)))
+                        and (TestEntity_.simpleString equal "Fry")
+        ).order(TestEntity_.simpleInt).build()
+        val resultsNew = newQuery.find()
+        assertEquals(2, resultsNew.size)
+        assertEquals(10, resultsNew[0].simpleInt)
+        assertEquals(12, resultsNew[1].simpleInt)
+
+        val newQueryOr = box.query(
+                // (EQ OR EQ) AND LESS
+                (TestEntity_.simpleString equal "Fry" or (TestEntity_.simpleString equal "Sarah"))
+                        and (TestEntity_.simpleInt less 12)
+        ).build().find()
+        assertEquals(1, newQueryOr.size) // only the Fry age 10
+
+        val newQueryAnd = box.query(
+                // EQ OR (EQ AND LESS)
+                TestEntity_.simpleString equal "Fry" or
+                        (TestEntity_.simpleString equal "Sarah" and (TestEntity_.simpleInt less 12))
+        ).build().find()
+        assertEquals(3, newQueryAnd.size) // all Fry's
+    }
+
+    @Test
+    fun intLessAndGreater() {
+        putTestEntitiesScalars()
+        val query = box.query(
+                TestEntity_.simpleInt greater 2003
+                        and (TestEntity_.simpleShort less 2107)
+        ).build()
+        assertEquals(3, query.count())
+    }
+
+    @Test
+    fun intBetween() {
+        putTestEntitiesScalars()
+        val query = box.query(
+                TestEntity_.simpleInt.between(2003, 2006)
+        ).build()
+        assertEquals(4, query.count())
+    }
+
+    @Test
+    fun intOneOf() {
+        putTestEntitiesScalars()
+
+        val valuesInt = intArrayOf(1, 1, 2, 3, 2003, 2007, 2002, -1)
+        val query = box.query(
+                TestEntity_.simpleInt oneOf(valuesInt) alias "int"
+        ).build()
+        assertEquals(3, query.count())
+
+        val valuesInt2 = intArrayOf(2003)
+        query.setParameter(TestEntity_.simpleInt, valuesInt2)
+        assertEquals(1, query.count())
+
+        val valuesInt3 = intArrayOf(2003, 2007)
+        query.setParameter("int", valuesInt3)
+        assertEquals(2, query.count())
+    }
+
+
+    @Test
+    fun or() {
+        putTestEntitiesScalars()
+        val query = box.query(
+                TestEntity_.simpleInt equal 2007 or (TestEntity_.simpleLong equal 3002)
+        ).build()
+        val entities = query.find()
+        assertEquals(2, entities.size.toLong())
+        assertEquals(3002, entities[0].simpleLong)
+        assertEquals(2007, entities[1].simpleInt.toLong())
+    }
+
+    @Test
+    fun and() {
+        putTestEntitiesScalars()
+        // Result if OR precedence (wrong): {}, AND precedence (expected): {2008}
+        val query = box.query(
+                TestEntity_.simpleInt equal 2006 and (TestEntity_.simpleInt equal 2007) or (TestEntity_.simpleInt equal 2008)
+        ).build()
+        val entities = query.find()
+        assertEquals(1, entities.size.toLong())
+        assertEquals(2008, entities[0].simpleInt.toLong())
+    }
+
+}
\ No newline at end of file
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java
index e135213c..dd94eafb 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/AbstractRelationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017-2023 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -27,7 +27,7 @@
 import io.objectbox.Box;
 import io.objectbox.BoxStore;
 import io.objectbox.BoxStoreBuilder;
-import io.objectbox.DebugFlags;
+import io.objectbox.config.DebugFlags;
 
 public abstract class AbstractRelationTest extends AbstractObjectBoxTest {
 
@@ -36,9 +36,9 @@ public abstract class AbstractRelationTest extends AbstractObjectBoxTest {
 
     @Override
     protected BoxStore createBoxStore() {
-        return MyObjectBox.builder().baseDirectory(boxStoreDir)
-                .debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE)
-                .build();
+        BoxStoreBuilder builder = MyObjectBox.builder().baseDirectory(boxStoreDir);
+        if (DEBUG_LOG) builder.debugFlags(DebugFlags.LOG_TRANSACTIONS_READ | DebugFlags.LOG_TRANSACTIONS_WRITE);
+        return builder.build();
     }
 
     @After
@@ -55,16 +55,23 @@ public void initBoxes() {
         orderBox.removeAll();
     }
 
+    /**
+     * Puts customer Joe.
+     */
     protected Customer putCustomer() {
+        return putCustomer("Joe");
+    }
+
+    Customer putCustomer(String name) {
         Customer customer = new Customer();
-        customer.setName("Joe");
+        customer.setName(name);
         customerBox.put(customer);
         return customer;
     }
 
     protected Order putOrder(@Nullable Customer customer, @Nullable String text) {
         Order order = new Order();
-        order.setCustomer(customer);
+        order.getCustomer().setTarget(customer);
         order.setText(text);
         orderBox.put(order);
         return order;
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/LinkQueryTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/LinkQueryTest.java
new file mode 100644
index 00000000..e8720b99
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/LinkQueryTest.java
@@ -0,0 +1,56 @@
+package io.objectbox.relation;
+
+import io.objectbox.query.Query;
+import io.objectbox.query.QueryBuilder;
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+
+/**
+ * Tests link conditions for queries to filter on related entities.
+ * <p>
+ * There are more extensive tests in integration tests.
+ */
+public class LinkQueryTest extends AbstractRelationTest {
+
+    @Test
+    public void link_withRegularCondition() {
+        Customer john = putCustomer("John");
+        putOrder(john, "Apples");
+        putOrder(john, "Oranges");
+
+        Customer alice = putCustomer("Alice");
+        putOrder(alice, "Apples");
+        putOrder(alice, "Bananas");
+
+        // link condition matches orders from Alice
+        // simple regular condition matches single order for both
+        QueryBuilder<Order> builder = orderBox
+                .query(Order_.text.equal("Apples"));
+        builder.link(Order_.customer)
+                .apply(Customer_.name.equal("Alice").alias("name"));
+
+        try (Query<Order> query = builder.build()) {
+            Order order = query.findUnique();
+            assertNotNull(order);
+            assertEquals("Apples", order.getText());
+            assertEquals("Alice", order.getCustomer().getTarget().getName());
+        }
+
+        // link condition matches orders from Alice
+        // complex regular conditions matches two orders for John, one for Alice
+        QueryBuilder<Order> builderComplex = orderBox
+                .query(Order_.text.equal("Apples").or(Order_.text.equal("Oranges")));
+        builderComplex.link(Order_.customer)
+                .apply(Customer_.name.equal("Alice"));
+
+        try (Query<Order> query = builderComplex.build()) {
+            Order order = query.findUnique();
+            assertNotNull(order);
+            assertEquals("Apples", order.getText());
+            assertEquals("Alice", order.getCustomer().getTarget().getName());
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java
index 0935b417..4f6c7981 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/MultithreadedRelationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,6 +16,7 @@
 
 package io.objectbox.relation;
 
+import io.objectbox.BoxStore;
 import org.junit.Test;
 
 import java.util.List;
@@ -42,7 +43,6 @@ public void testMultithreadedRelations() throws InterruptedException {
             threads[i].start();
         }
         int millis = runExtensiveTests ? 60 * 1000 : 50;
-        millis = 60 * 1000;
         boolean hasError = errorLatch.await(millis, TimeUnit.MILLISECONDS);
         running = false;
         assertNull(error);
@@ -77,8 +77,10 @@ public void run() {
                         Customer customer2 = all.get(random.nextInt(all.size()));
                         final List<Order> orders = customer2.getOrders();
                         if (all.size() > 100 + random.nextInt(100)) {
-                            System.out.println(">>" + all.size());
-                            System.out.println(">>>>" + orders.size());
+                            if (DEBUG_LOG) {
+                                System.out.println(">>" + all.size());
+                                System.out.println(">>>>" + orders.size());
+                            }
                             orderBox.remove(orders);
                             customerBox.remove(customer);
                         } else if (orders.size() > 1) {
@@ -92,6 +94,7 @@ public void run() {
                 }
                 errorLatch.countDown();
             }
+            store.closeThreadResources();
         }
     }
 }
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java
index b3a6a51c..6da0b595 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationEagerTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -94,20 +94,20 @@ public void testEagerToSingle() {
         // full list
         List<Order> orders = orderBox.query().eager(Order_.customer).build().find();
         assertEquals(2, orders.size());
-        assertTrue(orders.get(0).customer__toOne.isResolved());
-        assertTrue(orders.get(1).customer__toOne.isResolved());
+        assertTrue(orders.get(0).getCustomer().isResolved());
+        assertTrue(orders.get(1).getCustomer().isResolved());
 
         // full list paginated
         orders = orderBox.query().eager(Order_.customer).build().find(0, 10);
         assertEquals(2, orders.size());
-        assertTrue(orders.get(0).customer__toOne.isResolved());
-        assertTrue(orders.get(1).customer__toOne.isResolved());
+        assertTrue(orders.get(0).getCustomer().isResolved());
+        assertTrue(orders.get(1).getCustomer().isResolved());
 
         // list with eager limit
         orders = orderBox.query().eager(1, Order_.customer).build().find();
         assertEquals(2, orders.size());
-        assertTrue(orders.get(0).customer__toOne.isResolved());
-        assertFalse(orders.get(1).customer__toOne.isResolved());
+        assertTrue(orders.get(0).getCustomer().isResolved());
+        assertFalse(orders.get(1).getCustomer().isResolved());
 
         // forEach
         final int[] count = {0};
@@ -119,12 +119,12 @@ public void testEagerToSingle() {
 
         // first
         Order order = orderBox.query().eager(Order_.customer).build().findFirst();
-        assertTrue(order.customer__toOne.isResolved());
+        assertTrue(order.getCustomer().isResolved());
 
         // unique
         orderBox.remove(order);
         order = orderBox.query().eager(Order_.customer).build().findUnique();
-        assertTrue(order.customer__toOne.isResolved());
+        assertTrue(order.getCustomer().isResolved());
     }
 
     @Test
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java
index 8bb4ff08..89abfb71 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/RelationTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,9 +37,9 @@ public void testRelationToOne() {
 
         Order order1 = orderBox.get(order.getId());
         assertEquals(customer.getId(), order1.getCustomerId());
-        assertNull(order1.peekCustomer());
-        assertEquals(customer.getId(), order1.getCustomer().getId());
-        assertNotNull(order1.peekCustomer());
+        assertNull(order1.getCustomer().getCachedTarget());
+        assertEquals(customer.getId(), order1.getCustomer().getTarget().getId());
+        assertNotNull(order1.getCustomer().getCachedTarget());
     }
 
     @Test
@@ -85,7 +85,7 @@ public void testRelationToMany_activeRelationshipChanges() {
         ((ToMany<Order>) orders).reset();
         assertEquals(1, orders.size());
 
-        order2.setCustomer(null);
+        order2.getCustomer().setTarget(null);
         orderBox.put(order2);
 
         ((ToMany<Order>) orders).reset();
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java
index 57ada49e..90a56502 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyStandaloneTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -45,6 +45,7 @@ public void testPutAndGetPrimitives() {
         int sourceEntityId = info.sourceInfo.getEntityId();
         Cursor<Order> targetCursor = cursorSource.getTx().createCursor(Order.class);
         List<Order> related = targetCursor.getRelationEntities(sourceEntityId, info.relationId, customerId, false);
+        targetCursor.close();
         assertEquals(2, related.size());
         assertEquals(order1.getId(), related.get(0).getId());
         assertEquals(order2.getId(), related.get(1).getId());
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java
index 31adc972..1b9c0873 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToManyTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java
index 86be8fa7..1ab8b85a 100644
--- a/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/relation/ToOneTest.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -100,7 +100,7 @@ public void testPutNewSourceAndTarget() {
         Customer target = new Customer();
         target.setName("target1");
 
-        ToOne<Customer> toOne = source.customer__toOne;
+        ToOne<Customer> toOne = source.getCustomer();
         assertTrue(toOne.isResolved());
         assertTrue(toOne.isNull());
         assertNull(toOne.getCachedTarget());
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java
new file mode 100644
index 00000000..9ec4f81e
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/ConnectivityMonitorTest.java
@@ -0,0 +1,259 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import org.junit.Test;
+
+import java.util.List;
+
+import javax.annotation.Nullable;
+
+import io.objectbox.sync.listener.SyncChangeListener;
+import io.objectbox.sync.listener.SyncCompletedListener;
+import io.objectbox.sync.listener.SyncConnectionListener;
+import io.objectbox.sync.listener.SyncListener;
+import io.objectbox.sync.listener.SyncLoginListener;
+import io.objectbox.sync.listener.SyncTimeListener;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertThrows;
+
+public class ConnectivityMonitorTest {
+
+    @Test
+    public void reactsToObserverChanges() {
+        TestSyncClient testSyncClient = new TestSyncClient();
+        TestConnectivityMonitor testMonitor = new TestConnectivityMonitor();
+
+        // No observer set.
+        testMonitor.removeObserver();
+        assertEquals(0, testMonitor.onObserverSetCalled);
+        assertEquals(1, testMonitor.onObserverRemovedCalled);
+
+        testMonitor.reset();
+
+        testMonitor.setObserver(testSyncClient);
+        assertEquals(1, testMonitor.onObserverSetCalled);
+        assertEquals(0, testMonitor.onObserverRemovedCalled);
+
+        testMonitor.reset();
+
+        testMonitor.removeObserver();
+        assertEquals(0, testMonitor.onObserverSetCalled);
+        assertEquals(1, testMonitor.onObserverRemovedCalled);
+    }
+
+    @Test
+    public void settingNullObserverFails() {
+        TestConnectivityMonitor testMonitor = new TestConnectivityMonitor();
+
+        //noinspection ConstantConditions Ignore NotNull annotation on purpose.
+        assertThrows(IllegalArgumentException.class, () -> testMonitor.setObserver(null));
+    }
+
+    @Test
+    public void notifiesObserversOnlyIfSet() {
+        TestSyncClient testSyncClient = new TestSyncClient();
+        TestConnectivityMonitor testMonitor = new TestConnectivityMonitor();
+
+        testMonitor.setObserver(testSyncClient);
+        testMonitor.notifyConnectionAvailable();
+        assertEquals(1, testSyncClient.notifyConnectionAvailableCalled);
+
+        testSyncClient.reset();
+
+        testMonitor.removeObserver();
+        testMonitor.notifyConnectionAvailable();
+        assertEquals(0, testSyncClient.notifyConnectionAvailableCalled);
+    }
+
+    private static class TestConnectivityMonitor extends ConnectivityMonitor {
+
+        int onObserverSetCalled;
+        int onObserverRemovedCalled;
+
+        void reset() {
+            onObserverSetCalled = 0;
+            onObserverRemovedCalled = 0;
+        }
+
+        @Override
+        public void onObserverSet() {
+            onObserverSetCalled += 1;
+        }
+
+        @Override
+        public void onObserverRemoved() {
+            onObserverRemovedCalled += 1;
+        }
+    }
+
+    private static class TestSyncClient implements SyncClient {
+
+        int notifyConnectionAvailableCalled;
+
+        void reset() {
+            notifyConnectionAvailableCalled = 0;
+        }
+
+        @Override
+        public String getServerUrl() {
+            return null;
+        }
+
+        @Override
+        public MeshSync getMesh() {
+            return null;
+        }
+
+        @Override
+        public List<String> getUrls() {
+            return null;
+        }
+
+        @Override
+        public boolean isStarted() {
+            return false;
+        }
+
+        @Override
+        public boolean isLoggedIn() {
+            return false;
+        }
+
+        @Override
+        public long getLastLoginCode() {
+            return 0;
+        }
+
+        @Override
+        public long getServerTimeNanos() {
+            return 0;
+        }
+
+        @Override
+        public long getServerTimeDiffNanos() {
+            return 0;
+        }
+
+        @Override
+        public long getRoundtripTimeNanos() {
+            return 0;
+        }
+
+        @Override
+        public void setSyncLoginListener(@Nullable SyncLoginListener listener) {
+        }
+
+        @Override
+        public void setSyncCompletedListener(@Nullable SyncCompletedListener listener) {
+        }
+
+        @Override
+        public void setSyncConnectionListener(@Nullable SyncConnectionListener listener) {
+        }
+
+        @Override
+        public void setSyncListener(@Nullable SyncListener listener) {
+        }
+
+        @Override
+        public void setSyncChangeListener(@Nullable SyncChangeListener listener) {
+        }
+
+        @Override
+        public void setSyncTimeListener(@Nullable SyncTimeListener timeListener) {
+        }
+
+        @Override
+        public void putFilterVariable(String name, String value) {
+        }
+
+        @Override
+        public void removeFilterVariable(String name) {
+        }
+
+        @Override
+        public void removeAllFilterVariables() {
+        }
+
+        @Override
+        public void applyFilterVariables() {
+        }
+
+        @Override
+        public void setLoginCredentials(SyncCredentials credentials) {
+        }
+
+        @Override
+        public void setLoginCredentials(List<SyncCredentials> credentials) {
+        }
+
+        @Override
+        public void setLoginCredentials(SyncCredentials[] multipleCredentials) {
+        }
+
+        @Override
+        public boolean awaitFirstLogin(long millisToWait) {
+            return false;
+        }
+
+        @Override
+        public void start() {
+        }
+
+        @Override
+        public void stop() {
+        }
+
+        @Override
+        public void close() {
+        }
+
+        @Override
+        public boolean requestUpdates() {
+            return false;
+        }
+
+        @Override
+        public boolean requestUpdatesOnce() {
+            return false;
+        }
+
+        @Override
+        public boolean cancelUpdates() {
+            return false;
+        }
+
+        @Override
+        public boolean requestFullSync() {
+            return false;
+        }
+
+        @Override
+        public void notifyConnectionAvailable() {
+            notifyConnectionAvailableCalled += 1;
+        }
+
+        @Override
+        public ObjectsMessageBuilder startObjectsMessage(long flags, @Nullable String topic) {
+            return null;
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/PlatformTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/PlatformTest.java
new file mode 100644
index 00000000..5bdafecd
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/PlatformTest.java
@@ -0,0 +1,17 @@
+package io.objectbox.sync;
+
+import org.junit.Test;
+
+import io.objectbox.sync.internal.Platform;
+
+
+import static org.junit.Assert.assertNotNull;
+
+public class PlatformTest {
+
+    @Test
+    public void buildsAndNeverNull() {
+        assertNotNull(Platform.findPlatform());
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncMeshTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncMeshTest.java
new file mode 100644
index 00000000..9dbd68dd
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncMeshTest.java
@@ -0,0 +1,155 @@
+/*
+ * Copyright 2026 ObjectBox Ltd. <https://objectbox.io>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import org.junit.Test;
+
+import io.objectbox.AbstractObjectBoxTest;
+
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+
+/**
+ * Does basic tests of the peer-to-peer mesh sync API.
+ */
+public class SyncMeshTest extends AbstractObjectBoxTest {
+
+    private static final String TEST_MESH_ID = "test-mesh";
+    private static final String TEST_SERVER_URL = "ws://127.0.0.1:9999";
+
+    @Test
+    public void meshConfig_setsAllValues() {
+        MeshConfig config = InternalSyncAccess.createMeshConfig(TEST_MESH_ID)
+                .maxConnectionCount(4)
+                .backoffMillis(5000)
+                .evictionBackoffMillis(20000)
+                .requestTimeoutMillis(3000)
+                .advertisingDelayMillis(1000)
+                .advertisingRetryMillis(2000)
+                .advertisingRetryMaxMillis(30000)
+                .connectDelayMillis(500)
+                .initialDiscoveryDurationSeconds(20)
+                .discoveryDurationSeconds(10)
+                .discoveryPauseSeconds(30)
+                .discoveryPauseJitterSeconds(10)
+                .txLogBatchSizeKb(50)
+                .txLogBatchMaxCount(500);
+        InternalSyncAccess.addNetworkInternalHandle(config, 12345);
+
+        assertEquals(TEST_MESH_ID, config.meshId);
+        assertEquals(Integer.valueOf(4), config.maxConnectionCount);
+        assertEquals(Integer.valueOf(5000), config.backoffMillis);
+        assertEquals(Integer.valueOf(20000), config.evictionBackoffMillis);
+        assertEquals(Integer.valueOf(3000), config.requestTimeoutMillis);
+        assertEquals(Integer.valueOf(1000), config.advertisingDelayMillis);
+        assertEquals(Integer.valueOf(2000), config.advertisingRetryMillis);
+        assertEquals(Integer.valueOf(30000), config.advertisingRetryMaxMillis);
+        assertEquals(Integer.valueOf(500), config.connectDelayMillis);
+        assertEquals(Integer.valueOf(20), config.initialDiscoveryDurationSeconds);
+        assertEquals(Integer.valueOf(10), config.discoveryDurationSeconds);
+        assertEquals(Integer.valueOf(30), config.discoveryPauseSeconds);
+        assertEquals(Integer.valueOf(10), config.discoveryPauseJitterSeconds);
+        assertEquals(Integer.valueOf(50), config.txLogBatchSizeKb);
+        assertEquals(Integer.valueOf(500), config.txLogBatchMaxCount);
+        assertEquals(1, config.networkInternalHandles.size());
+        assertEquals(Long.valueOf(12345), config.networkInternalHandles.get(0));
+    }
+
+    @Test
+    public void meshConfig_defaultsToNoValues() {
+        MeshConfig config = InternalSyncAccess.createMeshConfig(TEST_MESH_ID);
+
+        assertEquals(TEST_MESH_ID, config.meshId);
+        assertNull(config.maxConnectionCount);
+        assertNull(config.backoffMillis);
+        assertNull(config.evictionBackoffMillis);
+        assertNull(config.requestTimeoutMillis);
+        assertNull(config.advertisingDelayMillis);
+        assertNull(config.advertisingRetryMillis);
+        assertNull(config.advertisingRetryMaxMillis);
+        assertNull(config.connectDelayMillis);
+        assertNull(config.initialDiscoveryDurationSeconds);
+        assertNull(config.discoveryDurationSeconds);
+        assertNull(config.discoveryPauseSeconds);
+        assertNull(config.discoveryPauseJitterSeconds);
+        assertNull(config.txLogBatchSizeKb);
+        assertNull(config.txLogBatchMaxCount);
+        assertEquals(0, config.networkInternalHandles.size());
+    }
+
+    @Test
+    public void meshConfig_emptyMeshId_throws() {
+        assertThrows(IllegalArgumentException.class, () -> InternalSyncAccess.createMeshConfig(""));
+        //noinspection DataFlowIssue
+        assertThrows(IllegalArgumentException.class, () -> InternalSyncAccess.createMeshConfig(null));
+    }
+
+    @Test
+    public void meshState_fromId_mapsKnownValues() {
+        MeshState[] states = MeshState.values();
+        for (MeshState state : states) {
+            assertEquals(state, MeshState.fromId(state.id));
+        }
+    }
+
+    @Test
+    public void meshState_fromId_mapsUnknownValues() {
+        assertEquals(MeshState.UNKNOWN, MeshState.fromId(-1));
+        MeshState[] states = MeshState.values();
+        assertEquals(MeshState.UNKNOWN, MeshState.fromId(states[states.length - 1].id + 1));
+    }
+
+    @Test
+    public void clientWithMesh_getMeshWorks() {
+        MeshConfig config = InternalSyncAccess.createMeshConfig(TEST_MESH_ID);
+
+        try (SyncClient client = Sync.client(store)
+                .url(TEST_SERVER_URL)
+                .credentials(SyncCredentials.none())
+                .mesh(config)
+                .build()) {
+            MeshSync mesh = client.getMesh();
+            assertNotNull(mesh);
+
+            assertEquals(MeshState.CREATED, mesh.getState());
+            assertEquals("Created", mesh.getStateString());
+            assertEquals(0, mesh.getConnectedPeerCount());
+            for (MeshStats counter : MeshStats.values()) {
+                assertEquals(0, mesh.getStats(counter));
+            }
+
+            client.close();
+            // The mesh is owned by the client, accessing it after close should throw
+            assertThrows(IllegalStateException.class, mesh::getState);
+            assertNull(this.store.getSyncClient());
+        }
+    }
+
+    @Test
+    public void clientWithoutMesh_getMeshReturnsNull() {
+        try (SyncClient client = Sync.client(store)
+                .url(TEST_SERVER_URL)
+                .credentials(SyncCredentials.none())
+                .build()) {
+            assertNull(client.getMesh());
+        }
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java
new file mode 100644
index 00000000..c73ab354
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/sync/SyncTest.java
@@ -0,0 +1,333 @@
+/*
+ * Copyright 2020-2025 ObjectBox Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.objectbox.sync;
+
+import org.junit.Test;
+import org.junit.function.ThrowingRunnable;
+
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import io.objectbox.AbstractObjectBoxTest;
+import io.objectbox.exception.FeatureNotAvailableException;
+
+
+import static org.junit.Assert.assertArrayEquals;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNotSame;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * This subproject includes JVM libraries with the Sync feature (so client only). These tests verify
+ * Java APIs behave as expected in that case.
+ * <p>
+ * The Java integration test repository has basic API tests that use JVM libraries without the Sync
+ * feature as well as extended functional tests for Sync client and server.
+ */
+public class SyncTest extends AbstractObjectBoxTest {
+
+    // Not specifying a port to use random available one to avoid collisions
+    // Not using encrypted connection (wss protocol) as this requires a working certificate setup
+    private static final String TEST_SERVER_URL = "ws://127.0.0.1";
+
+    @Test
+    public void clientIsAvailable() {
+        assertTrue(Sync.isAvailable());
+    }
+
+    @Test
+    public void serverIsNotAvailable() {
+        assertFalse(Sync.isServerAvailable());
+        assertFalse(Sync.isHybridAvailable());
+    }
+
+    @Test
+    public void creatingSyncServer_throws() {
+        FeatureNotAvailableException exception = assertThrows(
+                FeatureNotAvailableException.class,
+                () -> Sync.server(store, TEST_SERVER_URL, SyncCredentials.none())
+        );
+        String message = exception.getMessage();
+        assertTrue(message, message.contains("does not include the Sync Server feature")
+                && message.contains("https://objectbox.io/sync/"));
+    }
+
+    /**
+     * Can't re-use builder as credentials are cleared.
+     */
+    private SyncBuilder clientBuilder() {
+        return Sync.client(store)
+                .url(TEST_SERVER_URL)
+                .credentials(SyncCredentials.none());
+    }
+
+    @Test
+    public void clientReferenceIsKeptInStore() {
+        assertNull(store.getSyncClient());
+
+        // Once created, reference is added to store.
+        try (SyncClient client = clientBuilder().build()) {
+            assertNotNull(client);
+            assertEquals(client, store.getSyncClient());
+
+            // If created, creating again fails for same store.
+            IllegalStateException exception = assertThrows(
+                    IllegalStateException.class,
+                    clientBuilder()::build
+            );
+            assertEquals(
+                    "The given store is already associated with a Sync client, close it first.",
+                    exception.getMessage()
+            );
+        }
+        // Closing cleared reference from store
+        assertNull(store.getSyncClient());
+
+        // Creating again works after closing.
+        try (SyncClient client = clientBuilder().build()) {
+            assertNotNull(client);
+            assertEquals(client, store.getSyncClient());
+        }
+    }
+
+    @Test
+    public void clientStates_noServer() {
+        try (SyncClientImpl syncClient = (SyncClientImpl) clientBuilder().build()) {
+            assertEquals(SyncState.CREATED, syncClient.getSyncState());
+
+            syncClient.start();
+            assertEquals(SyncState.STARTED, syncClient.getSyncState());
+
+            syncClient.stop();
+            assertEquals(SyncState.STOPPED, syncClient.getSyncState());
+        }
+    }
+
+    @Test
+    public void clientIsClosed_nativeMethodsThrow() {
+        SyncClient syncClient = clientBuilder().build();
+
+        syncClient.close();
+
+        assertEquals(TEST_SERVER_URL, syncClient.getUrls().get(0));
+        assertEquals(0, syncClient.getLastLoginCode());
+        assertFalse(syncClient.isLoggedIn());
+        syncClient.setSyncLoginListener(null);
+        syncClient.setSyncCompletedListener(null);
+        syncClient.setSyncTimeListener(null);
+        syncClient.setSyncConnectionListener(null);
+        assertFalse(syncClient.isStarted());
+
+        assertThrows(IllegalStateException.class, syncClient::getServerTimeNanos);
+        assertThrows(IllegalStateException.class, syncClient::getServerTimeDiffNanos);
+        assertThrows(IllegalStateException.class, syncClient::getRoundtripTimeNanos);
+        assertThrows(IllegalStateException.class, ((SyncClientImpl) syncClient)::getSyncState);
+        assertThrows(IllegalStateException.class, () -> syncClient.setSyncChangeListener(null));
+        assertThrows(IllegalStateException.class, () -> syncClient.setSyncListener(null));
+        assertThrows(IllegalStateException.class, () -> syncClient.putFilterVariable("name", "value"));
+        assertThrows(IllegalStateException.class, () -> syncClient.removeFilterVariable("name"));
+        assertThrows(IllegalStateException.class, syncClient::removeAllFilterVariables);
+        assertThrows(IllegalStateException.class, () -> syncClient.setLoginCredentials(SyncCredentials.none()));
+
+        SyncCredentials[] multipleCredentials = new SyncCredentials[]{
+                SyncCredentials.userAndPassword("user", "password"),
+                SyncCredentials.jwtAccessToken("access-token")
+        };
+        assertThrows(IllegalStateException.class, () -> syncClient.setLoginCredentials(multipleCredentials));
+
+        assertThrows(IllegalStateException.class, () -> syncClient.awaitFirstLogin(1));
+        assertThrows(IllegalStateException.class, syncClient::start);
+        assertThrows(IllegalStateException.class, syncClient::stop);
+        assertThrows(IllegalStateException.class, syncClient::requestUpdates);
+        assertThrows(IllegalStateException.class, syncClient::requestUpdatesOnce);
+        assertThrows(IllegalStateException.class, syncClient::cancelUpdates);
+        assertThrows(IllegalStateException.class, syncClient::notifyConnectionAvailable);
+
+        // Calling close again shouldn't call native method again, so shouldn't throw.
+        // Needs to behave this way as close() is also called by finalize().
+        syncClient.close();
+    }
+
+    @Test
+    public void syncClient_missingStore_throws() {
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> Sync.client(null));
+    }
+
+    @Test
+    public void syncClient_missingUrl_throws() {
+        // If a null URL is passed
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> Sync.client(store).url(null));
+        List<String> nullUrl = new ArrayList<>();
+        nullUrl.add(null);
+        assertThrowsIsNull(() -> Sync.client(store).urls(nullUrl));
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> Sync.client(store).urls(null));
+
+        // If no URLs are passed
+        //noinspection resource
+        IllegalArgumentException noUrls = assertThrows(IllegalArgumentException.class,
+                () -> Sync.client(store).urls(Collections.emptyList()).build());
+        assertEquals("At least one URL must be added to sync client options", noUrls.getMessage());
+    }
+
+    @Test
+    public void syncClient_credentials() {
+        // If no credentials are passed
+        //noinspection resource
+        IllegalArgumentException noCreds = assertThrows(IllegalArgumentException.class,
+                () -> Sync.client(store).url(TEST_SERVER_URL).build());
+        assertTrue(noCreds.getMessage().contains("Credentials must be provided"));
+        //noinspection DataFlowIssue,resource
+        assertThrowsIsNull(() -> Sync.client(store).url(TEST_SERVER_URL)
+                .credentials((SyncCredentials) null).build());
+        //noinspection DataFlowIssue,resource
+        assertThrowsIsNull(() -> Sync.client(store).url(TEST_SERVER_URL)
+                .credentials((List<SyncCredentials>) null).build());
+
+        // If credentials are changed after creating the client
+        try (SyncClient syncClient = clientBuilder().build()) {
+            // Single credentials item
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials((SyncCredentials) null));
+            syncClient.setLoginCredentials(SyncCredentials.none());
+            syncClient.setLoginCredentials(SyncCredentials.google("secret"));
+            syncClient.setLoginCredentials(SyncCredentials.sharedSecret("secret"));
+            syncClient.setLoginCredentials(SyncCredentials.none());
+
+            // Multiple credentials items
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials((SyncCredentials[]) null));
+            SyncCredentials[] credentials = {
+                    SyncCredentials.sharedSecret("<shared-secret>"),
+                    SyncCredentials.jwtAccessToken("<jwt-access-token>")
+            };
+            syncClient.setLoginCredentials(credentials);
+            syncClient.setLoginCredentials(new SyncCredentials[]{});
+            IllegalArgumentException nullArrayItemEx = assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials(new SyncCredentials[]{
+                            SyncCredentials.sharedSecret("<shared-secret>"),
+                            null}));
+            assertTrue(nullArrayItemEx.getMessage().contains("credentials is not a supported type"));
+            // Note: the variant accepting a list forwards to the single item and array variant, so
+            // just test the error case.
+            IllegalArgumentException emptyListEx = assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.setLoginCredentials(new ArrayList<>()));
+            assertTrue(emptyListEx.getMessage().contains("Credentials must be provided"));
+        }
+    }
+
+    @Test
+    public void credentials_cloningAndClearing_works() {
+        SyncCredentialsToken credentials = (SyncCredentialsToken) SyncCredentials.sharedSecret("secret");
+        SyncCredentialsToken clonedCredentials = credentials.createClone();
+
+        assertNotSame(credentials, clonedCredentials);
+        assertArrayEquals(clonedCredentials.getTokenBytes(), credentials.getTokenBytes());
+        credentials.clear();
+        assertThrows(IllegalStateException.class, credentials::getTokenBytes);
+        assertArrayEquals(clonedCredentials.getTokenBytes(), "secret".getBytes(StandardCharsets.UTF_8));
+    }
+
+    @Test
+    public void syncClient_requestUpdatesMode() {
+        try (SyncClient syncClient = clientBuilder()
+                .requestUpdatesMode(SyncBuilder.RequestUpdatesMode.MANUAL)
+                .build()) {
+            // Try to change request updates mode while not connected.
+            syncClient.start();
+            // All below should return false, because the client is not connected.
+            assertFalse(syncClient.requestUpdatesOnce());
+            assertFalse(syncClient.requestUpdates());
+            assertFalse(syncClient.cancelUpdates());
+        }
+    }
+
+    @Test
+    public void syncClient_filterVariables() {
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> clientBuilder().filterVariable(null, ""));
+        //noinspection DataFlowIssue
+        assertThrowsIsNull(() -> clientBuilder().filterVariable("", null));
+
+        try (SyncClient syncClient = clientBuilder()
+                .filterVariable("test-var-1", "test value 1")
+                .build()) {
+            syncClient.putFilterVariable("test-var-2", "test value 2");
+            syncClient.removeFilterVariable("test-var-2");
+            syncClient.putFilterVariable("test-var-2", "");
+            syncClient.removeAllFilterVariables();
+            syncClient.applyFilterVariables(); // no-op as client is not logged in
+
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.putFilterVariable("", "value"));
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.putFilterVariable(null, "value"));
+            //noinspection DataFlowIssue
+            assertThrows(IllegalArgumentException.class,
+                    () -> syncClient.putFilterVariable("name", null));
+        }
+    }
+
+    @Test
+    public void syncClient_trustedCertificates() {
+        clientBuilder()
+                .trustedCertificates(new String[]{})
+                .build()
+                .close();
+
+        clientBuilder()
+                .trustedCertificates(new String[]{
+                        "/path/to/does-not-exist-1.crt",
+                        "/path/to/does-not-exist-2.crt"
+                })
+                .build()
+                .close();
+    }
+
+    @Test
+    public void syncClient_flags() {
+        clientBuilder()
+                .flags(-1)
+                .build()
+                .close();
+
+        clientBuilder()
+                .flags(SyncFlags.DebugLogIdMapping
+                        | SyncFlags.ClientKeepDataOnSyncError
+                        | SyncFlags.DebugLogFilterVariables
+                        | SyncFlags.RemoveWithObjectData
+                        | SyncFlags.DebugLogTxLogs
+                        | SyncFlags.SkipInvalidTxOps)
+                .build().close();
+    }
+
+    private void assertThrowsIsNull(ThrowingRunnable runnable) {
+        IllegalArgumentException isNullEx = assertThrows(IllegalArgumentException.class, runnable);
+        assertTrue(isNullEx.getMessage().contains("must not be null"));
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch.java
new file mode 100644
index 00000000..61aa29c8
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch.java
@@ -0,0 +1,25 @@
+package io.objectbox.tree;
+
+import io.objectbox.annotation.ConflictStrategy;
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.Id;
+import io.objectbox.annotation.Unique;
+import io.objectbox.relation.ToOne;
+
+@Entity
+public final class DataBranch {
+    @Id
+    long id;
+
+    @Unique(onConflict = ConflictStrategy.REPLACE)
+    String uid;
+
+    public ToOne<DataBranch> parent;
+    public ToOne<MetaBranch> metaBranch;
+
+    public String toString() {
+        return "DataBranch(id=" + this.id + ", uid=" + this.uid + ')';
+    }
+
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranchCursor.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranchCursor.java
new file mode 100644
index 00000000..7eb15a32
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranchCursor.java
@@ -0,0 +1,87 @@
+package io.objectbox.tree;
+
+import io.objectbox.BoxStore;
+import io.objectbox.Cursor;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.relation.ToOne;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * ObjectBox generated Cursor implementation for "DataBranch".
+ * Note that this is a low-level class: usually you should stick to the Box class.
+ */
+public final class DataBranchCursor extends Cursor<DataBranch> {
+    @Internal
+    static final class Factory implements CursorFactory<DataBranch> {
+        @Override
+        public Cursor<DataBranch> createCursor(io.objectbox.Transaction tx, long cursorHandle, BoxStore boxStoreForEntities) {
+            return new DataBranchCursor(tx, cursorHandle, boxStoreForEntities);
+        }
+    }
+
+    private static final DataBranch_.DataBranchIdGetter ID_GETTER = DataBranch_.__ID_GETTER;
+
+
+    private final static int __ID_uid = DataBranch_.uid.id;
+    private final static int __ID_parentId = DataBranch_.parentId.id;
+    private final static int __ID_metaBranchId = DataBranch_.metaBranchId.id;
+
+    public DataBranchCursor(io.objectbox.Transaction tx, long cursor, BoxStore boxStore) {
+        super(tx, cursor, DataBranch_.__INSTANCE, boxStore);
+    }
+
+    @Override
+    public long getId(DataBranch entity) {
+        return ID_GETTER.getId(entity);
+    }
+
+    /**
+     * Puts an object into its box.
+     *
+     * @return The ID of the object within its box.
+     */
+    @Override
+    public long put(DataBranch entity) {
+        ToOne<DataBranch> parent = entity.parent;
+        if(parent != null && parent.internalRequiresPutTarget()) {
+            Cursor<DataBranch> targetCursor = getRelationTargetCursor(DataBranch.class);
+            try {
+                parent.internalPutTarget(targetCursor);
+            } finally {
+                targetCursor.close();
+            }
+        }
+        ToOne<MetaBranch> metaBranch = entity.metaBranch;
+        if(metaBranch != null && metaBranch.internalRequiresPutTarget()) {
+            Cursor<MetaBranch> targetCursor = getRelationTargetCursor(MetaBranch.class);
+            try {
+                metaBranch.internalPutTarget(targetCursor);
+            } finally {
+                targetCursor.close();
+            }
+        }
+        String uid = entity.uid;
+        int __id1 = uid != null ? __ID_uid : 0;
+
+        long __assignedId = collect313311(cursor, entity.id, PUT_FLAG_FIRST | PUT_FLAG_COMPLETE,
+                __id1, uid, 0, null,
+                0, null, 0, null,
+                __ID_parentId, entity.parent.getTargetId(), __ID_metaBranchId, entity.metaBranch.getTargetId(),
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0);
+
+        entity.id = __assignedId;
+
+        attachEntity(entity);
+        return __assignedId;
+    }
+
+    private void attachEntity(DataBranch entity) {
+        // Transformer will create __boxStore field in entity and init it here:
+        // entity.__boxStore = boxStoreForEntities;
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java
new file mode 100644
index 00000000..26a0b8b4
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataBranch_.java
@@ -0,0 +1,125 @@
+
+package io.objectbox.tree;
+
+import io.objectbox.EntityInfo;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.internal.IdGetter;
+import io.objectbox.internal.ToOneGetter;
+import io.objectbox.relation.RelationInfo;
+import io.objectbox.relation.ToOne;
+import io.objectbox.tree.DataBranchCursor.Factory;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * Properties for entity "DataBranch". Can be used for QueryBuilder and for referencing DB names.
+ */
+public final class DataBranch_ implements EntityInfo<DataBranch> {
+
+    // Leading underscores for static constants to avoid naming conflicts with property names
+
+    public static final String __ENTITY_NAME = "DataBranch";
+
+    public static final int __ENTITY_ID = 44;
+
+    public static final Class<DataBranch> __ENTITY_CLASS = DataBranch.class;
+
+    public static final String __DB_NAME = "DataBranch";
+
+    public static final CursorFactory<DataBranch> __CURSOR_FACTORY = new Factory();
+
+    @Internal
+    static final DataBranchIdGetter __ID_GETTER = new DataBranchIdGetter();
+
+    public final static DataBranch_ __INSTANCE = new DataBranch_();
+
+    public final static io.objectbox.Property<DataBranch> id =
+        new io.objectbox.Property<>(__INSTANCE, 0, 1, long.class, "id", true, "id");
+
+    public final static io.objectbox.Property<DataBranch> uid =
+        new io.objectbox.Property<>(__INSTANCE, 1, 2, String.class, "uid");
+
+    public final static io.objectbox.Property<DataBranch> parentId =
+        new io.objectbox.Property<>(__INSTANCE, 2, 3, long.class, "parentId", true);
+
+    public final static io.objectbox.Property<DataBranch> metaBranchId =
+        new io.objectbox.Property<>(__INSTANCE, 3, 4, long.class, "metaBranchId", true);
+
+    @SuppressWarnings("unchecked")
+    public final static io.objectbox.Property<DataBranch>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
+        id,
+        uid,
+        parentId,
+        metaBranchId
+    };
+
+    public final static io.objectbox.Property<DataBranch> __ID_PROPERTY = id;
+
+    @Override
+    public String getEntityName() {
+        return __ENTITY_NAME;
+    }
+
+    @Override
+    public int getEntityId() {
+        return __ENTITY_ID;
+    }
+
+    @Override
+    public Class<DataBranch> getEntityClass() {
+        return __ENTITY_CLASS;
+    }
+
+    @Override
+    public String getDbName() {
+        return __DB_NAME;
+    }
+
+    @Override
+    public io.objectbox.Property<DataBranch>[] getAllProperties() {
+        return __ALL_PROPERTIES;
+    }
+
+    @Override
+    public io.objectbox.Property<DataBranch> getIdProperty() {
+        return __ID_PROPERTY;
+    }
+
+    @Override
+    public IdGetter<DataBranch> getIdGetter() {
+        return __ID_GETTER;
+    }
+
+    @Override
+    public CursorFactory<DataBranch> getCursorFactory() {
+        return __CURSOR_FACTORY;
+    }
+
+    @Internal
+    static final class DataBranchIdGetter implements IdGetter<DataBranch> {
+        @Override
+        public long getId(DataBranch object) {
+            return object.id;
+        }
+    }
+
+    /** To-one relation "parent" to target entity "DataBranch". */
+    public static final RelationInfo<DataBranch, DataBranch> parent =
+            new RelationInfo<>(DataBranch_.__INSTANCE, DataBranch_.__INSTANCE, parentId, new ToOneGetter<DataBranch, DataBranch>() {
+                @Override
+                public ToOne<DataBranch> getToOne(DataBranch entity) {
+                    return entity.parent;
+                }
+            });
+
+    /** To-one relation "metaBranch" to target entity "MetaBranch". */
+    public static final RelationInfo<DataBranch, MetaBranch> metaBranch =
+            new RelationInfo<>(DataBranch_.__INSTANCE, MetaBranch_.__INSTANCE, metaBranchId, new ToOneGetter<DataBranch, MetaBranch>() {
+                @Override
+                public ToOne<MetaBranch> getToOne(DataBranch entity) {
+                    return entity.metaBranch;
+                }
+            });
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf.java
new file mode 100644
index 00000000..41968adc
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf.java
@@ -0,0 +1,97 @@
+package io.objectbox.tree;
+
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.Id;
+import io.objectbox.relation.ToOne;
+
+import java.util.Arrays;
+
+@Entity
+public final class DataLeaf {
+    @Id
+    long id;
+    long valueInt;
+    double valueDouble;
+    String valueString;
+    String[] valueStrings;
+    public ToOne<DataBranch> dataBranch;
+    public ToOne<MetaLeaf> metaLeaf;
+
+    public DataLeaf(long id, long valueInt, double valueDouble, String valueString, String[] valueStrings) {
+        this.id = id;
+        this.valueInt = valueInt;
+        this.valueDouble = valueDouble;
+        this.valueString = valueString;
+        this.valueStrings = valueStrings;
+    }
+
+    public final long getId() {
+        return this.id;
+    }
+
+    public final void setId(long id) {
+        this.id = id;
+    }
+
+    public final long getValueInt() {
+        return this.valueInt;
+    }
+
+    public final void setValueInt(long valueInt) {
+        this.valueInt = valueInt;
+    }
+
+    public final double getValueDouble() {
+        return this.valueDouble;
+    }
+
+    public final void setValueDouble(double valueDouble) {
+        this.valueDouble = valueDouble;
+    }
+
+    public final String getValueString() {
+        return this.valueString;
+    }
+
+    public final void setValueString(String valueString) {
+        this.valueString = valueString;
+    }
+
+    public final String[] getValueStrings() {
+        return this.valueStrings;
+    }
+
+    public final void setValueStrings(String[] valueStrings) {
+        this.valueStrings = valueStrings;
+    }
+
+    public ToOne<DataBranch> getDataBranch() {
+        return dataBranch;
+    }
+
+    public void setDataBranch(ToOne<DataBranch> dataBranch) {
+        this.dataBranch = dataBranch;
+    }
+
+    public ToOne<MetaLeaf> getMetaLeaf() {
+        return metaLeaf;
+    }
+
+    public void setMetaLeaf(ToOne<MetaLeaf> metaLeaf) {
+        this.metaLeaf = metaLeaf;
+    }
+
+    public String toString() {
+        return "DataAttribute(id=" + this.id + ", valueInt=" + this.valueInt + ", valueDouble=" + this.valueDouble + ", valueString=" + this.valueString + ", valueStrings=" + Arrays.toString(this.valueStrings) + ')';
+    }
+
+    public int hashCode() {
+        int result = Long.hashCode(this.id);
+        result = result * 31 + Long.hashCode(this.valueInt);
+        result = result * 31 + Double.hashCode(this.valueDouble);
+        result = result * 31 + this.valueString.hashCode();
+        result = result * 31 + Arrays.hashCode(this.valueStrings);
+        return result;
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeafCursor.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeafCursor.java
new file mode 100644
index 00000000..1b782659
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeafCursor.java
@@ -0,0 +1,96 @@
+package io.objectbox.tree;
+
+import io.objectbox.BoxStore;
+import io.objectbox.Cursor;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.relation.ToOne;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * ObjectBox generated Cursor implementation for "DataLeaf".
+ * Note that this is a low-level class: usually you should stick to the Box class.
+ */
+public final class DataLeafCursor extends Cursor<DataLeaf> {
+    @Internal
+    static final class Factory implements CursorFactory<DataLeaf> {
+        @Override
+        public Cursor<DataLeaf> createCursor(io.objectbox.Transaction tx, long cursorHandle, BoxStore boxStoreForEntities) {
+            return new DataLeafCursor(tx, cursorHandle, boxStoreForEntities);
+        }
+    }
+
+    private static final DataLeaf_.DataLeafIdGetter ID_GETTER = DataLeaf_.__ID_GETTER;
+
+
+    private final static int __ID_valueInt = DataLeaf_.valueInt.id;
+    private final static int __ID_valueDouble = DataLeaf_.valueDouble.id;
+    private final static int __ID_valueString = DataLeaf_.valueString.id;
+    private final static int __ID_valueStrings = DataLeaf_.valueStrings.id;
+    private final static int __ID_dataBranchId = DataLeaf_.dataBranchId.id;
+    private final static int __ID_metaLeafId = DataLeaf_.metaLeafId.id;
+
+    public DataLeafCursor(io.objectbox.Transaction tx, long cursor, BoxStore boxStore) {
+        super(tx, cursor, DataLeaf_.__INSTANCE, boxStore);
+    }
+
+    @Override
+    public long getId(DataLeaf entity) {
+        return ID_GETTER.getId(entity);
+    }
+
+    /**
+     * Puts an object into its box.
+     *
+     * @return The ID of the object within its box.
+     */
+    @Override
+    public long put(DataLeaf entity) {
+        ToOne<DataBranch> dataBranch = entity.dataBranch;
+        if(dataBranch != null && dataBranch.internalRequiresPutTarget()) {
+            Cursor<DataBranch> targetCursor = getRelationTargetCursor(DataBranch.class);
+            try {
+                dataBranch.internalPutTarget(targetCursor);
+            } finally {
+                targetCursor.close();
+            }
+        }
+        ToOne<MetaLeaf> metaLeaf = entity.metaLeaf;
+        if(metaLeaf != null && metaLeaf.internalRequiresPutTarget()) {
+            Cursor<MetaLeaf> targetCursor = getRelationTargetCursor(MetaLeaf.class);
+            try {
+                metaLeaf.internalPutTarget(targetCursor);
+            } finally {
+                targetCursor.close();
+            }
+        }
+        String[] valueStrings = entity.valueStrings;
+        int __id4 = valueStrings != null ? __ID_valueStrings : 0;
+
+        collectStringArray(cursor, 0, PUT_FLAG_FIRST,
+                __id4, valueStrings);
+
+        String valueString = entity.valueString;
+        int __id3 = valueString != null ? __ID_valueString : 0;
+
+        long __assignedId = collect313311(cursor, entity.id, PUT_FLAG_COMPLETE,
+                __id3, valueString, 0, null,
+                0, null, 0, null,
+                __ID_valueInt, entity.valueInt, __ID_dataBranchId, entity.dataBranch.getTargetId(),
+                __ID_metaLeafId, entity.metaLeaf.getTargetId(), 0, 0,
+                0, 0, 0, 0,
+                0, 0, __ID_valueDouble, entity.valueDouble);
+
+        entity.id = __assignedId;
+
+        attachEntity(entity);
+        return __assignedId;
+    }
+
+    private void attachEntity(DataLeaf entity) {
+        // Transformer will create __boxStore field in entity and init it here:
+        // entity.__boxStore = boxStoreForEntities;
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java
new file mode 100644
index 00000000..a5068560
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/DataLeaf_.java
@@ -0,0 +1,137 @@
+
+package io.objectbox.tree;
+
+import io.objectbox.EntityInfo;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.internal.IdGetter;
+import io.objectbox.internal.ToOneGetter;
+import io.objectbox.relation.RelationInfo;
+import io.objectbox.relation.ToOne;
+import io.objectbox.tree.DataLeafCursor.Factory;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * Properties for entity "DataLeaf". Can be used for QueryBuilder and for referencing DB names.
+ */
+public final class DataLeaf_ implements EntityInfo<DataLeaf> {
+
+    // Leading underscores for static constants to avoid naming conflicts with property names
+
+    public static final String __ENTITY_NAME = "DataLeaf";
+
+    public static final int __ENTITY_ID = 46;
+
+    public static final Class<DataLeaf> __ENTITY_CLASS = DataLeaf.class;
+
+    public static final String __DB_NAME = "DataLeaf";
+
+    public static final CursorFactory<DataLeaf> __CURSOR_FACTORY = new Factory();
+
+    @Internal
+    static final DataLeafIdGetter __ID_GETTER = new DataLeafIdGetter();
+
+    public final static DataLeaf_ __INSTANCE = new DataLeaf_();
+
+    public final static io.objectbox.Property<DataLeaf> id =
+        new io.objectbox.Property<>(__INSTANCE, 0, 1, long.class, "id", true, "id");
+
+    public final static io.objectbox.Property<DataLeaf> valueInt =
+        new io.objectbox.Property<>(__INSTANCE, 1, 2, long.class, "valueInt");
+
+    public final static io.objectbox.Property<DataLeaf> valueDouble =
+        new io.objectbox.Property<>(__INSTANCE, 2, 3, double.class, "valueDouble");
+
+    public final static io.objectbox.Property<DataLeaf> valueString =
+        new io.objectbox.Property<>(__INSTANCE, 3, 4, String.class, "valueString");
+
+    public final static io.objectbox.Property<DataLeaf> valueStrings =
+        new io.objectbox.Property<>(__INSTANCE, 4, 5, String[].class, "valueStrings");
+
+    public final static io.objectbox.Property<DataLeaf> dataBranchId =
+        new io.objectbox.Property<>(__INSTANCE, 5, 6, long.class, "dataBranchId", true);
+
+    public final static io.objectbox.Property<DataLeaf> metaLeafId =
+        new io.objectbox.Property<>(__INSTANCE, 6, 7, long.class, "metaLeafId", true);
+
+    @SuppressWarnings("unchecked")
+    public final static io.objectbox.Property<DataLeaf>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
+        id,
+        valueInt,
+        valueDouble,
+        valueString,
+        valueStrings,
+        dataBranchId,
+        metaLeafId
+    };
+
+    public final static io.objectbox.Property<DataLeaf> __ID_PROPERTY = id;
+
+    @Override
+    public String getEntityName() {
+        return __ENTITY_NAME;
+    }
+
+    @Override
+    public int getEntityId() {
+        return __ENTITY_ID;
+    }
+
+    @Override
+    public Class<DataLeaf> getEntityClass() {
+        return __ENTITY_CLASS;
+    }
+
+    @Override
+    public String getDbName() {
+        return __DB_NAME;
+    }
+
+    @Override
+    public io.objectbox.Property<DataLeaf>[] getAllProperties() {
+        return __ALL_PROPERTIES;
+    }
+
+    @Override
+    public io.objectbox.Property<DataLeaf> getIdProperty() {
+        return __ID_PROPERTY;
+    }
+
+    @Override
+    public IdGetter<DataLeaf> getIdGetter() {
+        return __ID_GETTER;
+    }
+
+    @Override
+    public CursorFactory<DataLeaf> getCursorFactory() {
+        return __CURSOR_FACTORY;
+    }
+
+    @Internal
+    static final class DataLeafIdGetter implements IdGetter<DataLeaf> {
+        @Override
+        public long getId(DataLeaf object) {
+            return object.id;
+        }
+    }
+
+    /** To-one relation "dataBranch" to target entity "DataBranch". */
+    public static final RelationInfo<DataLeaf, DataBranch> dataBranch =
+            new RelationInfo<>(DataLeaf_.__INSTANCE, io.objectbox.tree.DataBranch_.__INSTANCE, dataBranchId, new ToOneGetter<DataLeaf, DataBranch>() {
+                @Override
+                public ToOne<DataBranch> getToOne(DataLeaf entity) {
+                    return entity.dataBranch;
+                }
+            });
+
+    /** To-one relation "metaLeaf" to target entity "MetaLeaf". */
+    public static final RelationInfo<DataLeaf, MetaLeaf> metaLeaf =
+            new RelationInfo<>(DataLeaf_.__INSTANCE, io.objectbox.tree.MetaLeaf_.__INSTANCE, metaLeafId, new ToOneGetter<DataLeaf, MetaLeaf>() {
+                @Override
+                public ToOne<MetaLeaf> getToOne(DataLeaf entity) {
+                    return entity.metaLeaf;
+                }
+            });
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch.java
new file mode 100644
index 00000000..d1536828
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch.java
@@ -0,0 +1,48 @@
+package io.objectbox.tree;
+
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.Id;
+import io.objectbox.relation.ToOne;
+
+@Entity
+public final class MetaBranch {
+    @Id
+    long id;
+
+    String name;
+    String description;
+
+    public ToOne<MetaBranch> parent;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public ToOne<MetaBranch> getParent() {
+        return parent;
+    }
+
+    public void setParent(ToOne<MetaBranch> parent) {
+        this.parent = parent;
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranchCursor.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranchCursor.java
new file mode 100644
index 00000000..bd08e252
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranchCursor.java
@@ -0,0 +1,80 @@
+package io.objectbox.tree;
+
+import io.objectbox.BoxStore;
+import io.objectbox.Cursor;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.relation.ToOne;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * ObjectBox generated Cursor implementation for "MetaBranch".
+ * Note that this is a low-level class: usually you should stick to the Box class.
+ */
+public final class MetaBranchCursor extends Cursor<MetaBranch> {
+    @Internal
+    static final class Factory implements CursorFactory<MetaBranch> {
+        @Override
+        public Cursor<MetaBranch> createCursor(io.objectbox.Transaction tx, long cursorHandle, BoxStore boxStoreForEntities) {
+            return new MetaBranchCursor(tx, cursorHandle, boxStoreForEntities);
+        }
+    }
+
+    private static final MetaBranch_.MetaBranchIdGetter ID_GETTER = MetaBranch_.__ID_GETTER;
+
+
+    private final static int __ID_name = MetaBranch_.name.id;
+    private final static int __ID_description = MetaBranch_.description.id;
+    private final static int __ID_parentId = MetaBranch_.parentId.id;
+
+    public MetaBranchCursor(io.objectbox.Transaction tx, long cursor, BoxStore boxStore) {
+        super(tx, cursor, MetaBranch_.__INSTANCE, boxStore);
+    }
+
+    @Override
+    public long getId(MetaBranch entity) {
+        return ID_GETTER.getId(entity);
+    }
+
+    /**
+     * Puts an object into its box.
+     *
+     * @return The ID of the object within its box.
+     */
+    @Override
+    public long put(MetaBranch entity) {
+        ToOne<MetaBranch> parent = entity.parent;
+        if(parent != null && parent.internalRequiresPutTarget()) {
+            Cursor<MetaBranch> targetCursor = getRelationTargetCursor(MetaBranch.class);
+            try {
+                parent.internalPutTarget(targetCursor);
+            } finally {
+                targetCursor.close();
+            }
+        }
+        String name = entity.name;
+        int __id1 = name != null ? __ID_name : 0;
+        String description = entity.description;
+        int __id2 = description != null ? __ID_description : 0;
+
+        long __assignedId = collect313311(cursor, entity.id, PUT_FLAG_FIRST | PUT_FLAG_COMPLETE,
+                __id1, name, __id2, description,
+                0, null, 0, null,
+                __ID_parentId, entity.parent.getTargetId(), 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0);
+
+        entity.id = __assignedId;
+
+        attachEntity(entity);
+        return __assignedId;
+    }
+
+    private void attachEntity(MetaBranch entity) {
+        // Transformer will create __boxStore field in entity and init it here:
+        // entity.__boxStore = boxStoreForEntities;
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java
new file mode 100644
index 00000000..cfbe6893
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaBranch_.java
@@ -0,0 +1,116 @@
+
+package io.objectbox.tree;
+
+import io.objectbox.EntityInfo;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.internal.IdGetter;
+import io.objectbox.internal.ToOneGetter;
+import io.objectbox.relation.RelationInfo;
+import io.objectbox.relation.ToOne;
+import io.objectbox.tree.MetaBranchCursor.Factory;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * Properties for entity "MetaBranch". Can be used for QueryBuilder and for referencing DB names.
+ */
+public final class MetaBranch_ implements EntityInfo<MetaBranch> {
+
+    // Leading underscores for static constants to avoid naming conflicts with property names
+
+    public static final String __ENTITY_NAME = "MetaBranch";
+
+    public static final int __ENTITY_ID = 45;
+
+    public static final Class<MetaBranch> __ENTITY_CLASS = MetaBranch.class;
+
+    public static final String __DB_NAME = "MetaBranch";
+
+    public static final CursorFactory<MetaBranch> __CURSOR_FACTORY = new Factory();
+
+    @Internal
+    static final MetaBranchIdGetter __ID_GETTER = new MetaBranchIdGetter();
+
+    public final static MetaBranch_ __INSTANCE = new MetaBranch_();
+
+    public final static io.objectbox.Property<MetaBranch> id =
+        new io.objectbox.Property<>(__INSTANCE, 0, 1, long.class, "id", true, "id");
+
+    public final static io.objectbox.Property<MetaBranch> name =
+        new io.objectbox.Property<>(__INSTANCE, 1, 2, String.class, "name");
+
+    public final static io.objectbox.Property<MetaBranch> description =
+        new io.objectbox.Property<>(__INSTANCE, 2, 3, String.class, "description");
+
+    public final static io.objectbox.Property<MetaBranch> parentId =
+        new io.objectbox.Property<>(__INSTANCE, 3, 4, long.class, "parentId", true);
+
+    @SuppressWarnings("unchecked")
+    public final static io.objectbox.Property<MetaBranch>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
+        id,
+        name,
+        description,
+        parentId
+    };
+
+    public final static io.objectbox.Property<MetaBranch> __ID_PROPERTY = id;
+
+    @Override
+    public String getEntityName() {
+        return __ENTITY_NAME;
+    }
+
+    @Override
+    public int getEntityId() {
+        return __ENTITY_ID;
+    }
+
+    @Override
+    public Class<MetaBranch> getEntityClass() {
+        return __ENTITY_CLASS;
+    }
+
+    @Override
+    public String getDbName() {
+        return __DB_NAME;
+    }
+
+    @Override
+    public io.objectbox.Property<MetaBranch>[] getAllProperties() {
+        return __ALL_PROPERTIES;
+    }
+
+    @Override
+    public io.objectbox.Property<MetaBranch> getIdProperty() {
+        return __ID_PROPERTY;
+    }
+
+    @Override
+    public IdGetter<MetaBranch> getIdGetter() {
+        return __ID_GETTER;
+    }
+
+    @Override
+    public CursorFactory<MetaBranch> getCursorFactory() {
+        return __CURSOR_FACTORY;
+    }
+
+    @Internal
+    static final class MetaBranchIdGetter implements IdGetter<MetaBranch> {
+        @Override
+        public long getId(MetaBranch object) {
+            return object.id;
+        }
+    }
+
+    /** To-one relation "parent" to target entity "MetaBranch". */
+    public static final RelationInfo<MetaBranch, MetaBranch> parent =
+            new RelationInfo<>(MetaBranch_.__INSTANCE, MetaBranch_.__INSTANCE, parentId, new ToOneGetter<MetaBranch, MetaBranch>() {
+                @Override
+                public ToOne<MetaBranch> getToOne(MetaBranch entity) {
+                    return entity.parent;
+                }
+            });
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf.java
new file mode 100644
index 00000000..f6ca6810
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf.java
@@ -0,0 +1,108 @@
+package io.objectbox.tree;
+
+import io.objectbox.annotation.Entity;
+import io.objectbox.annotation.Id;
+import io.objectbox.annotation.Unsigned;
+import io.objectbox.relation.ToOne;
+
+@Entity
+public final class MetaLeaf {
+    @Id
+    long id;
+
+    String name;
+    String description;
+
+    @Unsigned
+    private int flags;
+
+    @Unsigned
+    private short valueType;
+
+    String[] valueEnum;
+    String valueUnit;
+    String valueMin;
+    String valueMax;
+
+    public ToOne<MetaBranch> branch;
+
+    public long getId() {
+        return id;
+    }
+
+    public void setId(long id) {
+        this.id = id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public int getFlags() {
+        return flags;
+    }
+
+    public void setFlags(int flags) {
+        this.flags = flags;
+    }
+
+    public short getValueType() {
+        return valueType;
+    }
+
+    public void setValueType(short valueType) {
+        this.valueType = valueType;
+    }
+
+    public String[] getValueEnum() {
+        return valueEnum;
+    }
+
+    public void setValueEnum(String[] valueEnum) {
+        this.valueEnum = valueEnum;
+    }
+
+    public String getValueUnit() {
+        return valueUnit;
+    }
+
+    public void setValueUnit(String valueUnit) {
+        this.valueUnit = valueUnit;
+    }
+
+    public String getValueMin() {
+        return valueMin;
+    }
+
+    public void setValueMin(String valueMin) {
+        this.valueMin = valueMin;
+    }
+
+    public String getValueMax() {
+        return valueMax;
+    }
+
+    public void setValueMax(String valueMax) {
+        this.valueMax = valueMax;
+    }
+
+    public ToOne<MetaBranch> getBranch() {
+        return branch;
+    }
+
+    public void setBranch(ToOne<MetaBranch> branch) {
+        this.branch = branch;
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeafCursor.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeafCursor.java
new file mode 100644
index 00000000..a8b2abec
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeafCursor.java
@@ -0,0 +1,103 @@
+package io.objectbox.tree;
+
+import io.objectbox.BoxStore;
+import io.objectbox.Cursor;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.relation.ToOne;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * ObjectBox generated Cursor implementation for "MetaLeaf".
+ * Note that this is a low-level class: usually you should stick to the Box class.
+ */
+public final class MetaLeafCursor extends Cursor<MetaLeaf> {
+    @Internal
+    static final class Factory implements CursorFactory<MetaLeaf> {
+        @Override
+        public Cursor<MetaLeaf> createCursor(io.objectbox.Transaction tx, long cursorHandle, BoxStore boxStoreForEntities) {
+            return new MetaLeafCursor(tx, cursorHandle, boxStoreForEntities);
+        }
+    }
+
+    private static final MetaLeaf_.MetaLeafIdGetter ID_GETTER = MetaLeaf_.__ID_GETTER;
+
+
+    private final static int __ID_name = MetaLeaf_.name.id;
+    private final static int __ID_description = MetaLeaf_.description.id;
+    private final static int __ID_flags = MetaLeaf_.flags.id;
+    private final static int __ID_valueType = MetaLeaf_.valueType.id;
+    private final static int __ID_valueEnum = MetaLeaf_.valueEnum.id;
+    private final static int __ID_valueUnit = MetaLeaf_.valueUnit.id;
+    private final static int __ID_valueMin = MetaLeaf_.valueMin.id;
+    private final static int __ID_valueMax = MetaLeaf_.valueMax.id;
+    private final static int __ID_branchId = MetaLeaf_.branchId.id;
+
+    public MetaLeafCursor(io.objectbox.Transaction tx, long cursor, BoxStore boxStore) {
+        super(tx, cursor, MetaLeaf_.__INSTANCE, boxStore);
+    }
+
+    @Override
+    public long getId(MetaLeaf entity) {
+        return ID_GETTER.getId(entity);
+    }
+
+    /**
+     * Puts an object into its box.
+     *
+     * @return The ID of the object within its box.
+     */
+    @Override
+    public long put(MetaLeaf entity) {
+        ToOne<MetaBranch> branch = entity.branch;
+        if(branch != null && branch.internalRequiresPutTarget()) {
+            Cursor<MetaBranch> targetCursor = getRelationTargetCursor(MetaBranch.class);
+            try {
+                branch.internalPutTarget(targetCursor);
+            } finally {
+                targetCursor.close();
+            }
+        }
+        String[] valueEnum = entity.getValueEnum();
+        int __id5 = valueEnum != null ? __ID_valueEnum : 0;
+
+        collectStringArray(cursor, 0, PUT_FLAG_FIRST,
+                __id5, valueEnum);
+
+        String name = entity.getName();
+        int __id1 = name != null ? __ID_name : 0;
+        String description = entity.getDescription();
+        int __id2 = description != null ? __ID_description : 0;
+        String valueUnit = entity.getValueUnit();
+        int __id6 = valueUnit != null ? __ID_valueUnit : 0;
+        String valueMin = entity.getValueMin();
+        int __id7 = valueMin != null ? __ID_valueMin : 0;
+
+        collect400000(cursor, 0, 0,
+                __id1, name, __id2, description,
+                __id6, valueUnit, __id7, valueMin);
+
+        String valueMax = entity.getValueMax();
+        int __id8 = valueMax != null ? __ID_valueMax : 0;
+
+        long __assignedId = collect313311(cursor, entity.getId(), PUT_FLAG_COMPLETE,
+                __id8, valueMax, 0, null,
+                0, null, 0, null,
+                __ID_branchId, entity.branch.getTargetId(), __ID_flags, entity.getFlags(),
+                __ID_valueType, entity.getValueType(), 0, 0,
+                0, 0, 0, 0,
+                0, 0, 0, 0);
+
+        entity.setId(__assignedId);
+
+        attachEntity(entity);
+        return __assignedId;
+    }
+
+    private void attachEntity(MetaLeaf entity) {
+        // Transformer will create __boxStore field in entity and init it here:
+        // entity.__boxStore = boxStoreForEntities;
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java
new file mode 100644
index 00000000..0610fee8
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MetaLeaf_.java
@@ -0,0 +1,139 @@
+
+package io.objectbox.tree;
+
+import io.objectbox.EntityInfo;
+import io.objectbox.annotation.apihint.Internal;
+import io.objectbox.internal.CursorFactory;
+import io.objectbox.internal.IdGetter;
+import io.objectbox.internal.ToOneGetter;
+import io.objectbox.relation.RelationInfo;
+import io.objectbox.relation.ToOne;
+
+// THIS CODE IS GENERATED BY ObjectBox, DO NOT EDIT.
+
+/**
+ * Properties for entity "MetaLeaf". Can be used for QueryBuilder and for referencing DB names.
+ */
+public final class MetaLeaf_ implements EntityInfo<MetaLeaf> {
+
+    // Leading underscores for static constants to avoid naming conflicts with property names
+
+    public static final String __ENTITY_NAME = "MetaLeaf";
+
+    public static final int __ENTITY_ID = 47;
+
+    public static final Class<MetaLeaf> __ENTITY_CLASS = MetaLeaf.class;
+
+    public static final String __DB_NAME = "MetaLeaf";
+
+    public static final CursorFactory<MetaLeaf> __CURSOR_FACTORY = new MetaLeafCursor.Factory();
+
+    @Internal
+    static final MetaLeafIdGetter __ID_GETTER = new MetaLeafIdGetter();
+
+    public final static MetaLeaf_ __INSTANCE = new MetaLeaf_();
+
+    public final static io.objectbox.Property<MetaLeaf> id =
+        new io.objectbox.Property<>(__INSTANCE, 0, 1, long.class, "id", true, "id");
+
+    public final static io.objectbox.Property<MetaLeaf> name =
+        new io.objectbox.Property<>(__INSTANCE, 1, 2, String.class, "name");
+
+    public final static io.objectbox.Property<MetaLeaf> description =
+        new io.objectbox.Property<>(__INSTANCE, 2, 3, String.class, "description");
+
+    public final static io.objectbox.Property<MetaLeaf> flags =
+        new io.objectbox.Property<>(__INSTANCE, 3, 4, int.class, "flags");
+
+    public final static io.objectbox.Property<MetaLeaf> valueType =
+        new io.objectbox.Property<>(__INSTANCE, 4, 5, short.class, "valueType");
+
+    public final static io.objectbox.Property<MetaLeaf> valueEnum =
+        new io.objectbox.Property<>(__INSTANCE, 5, 6, String[].class, "valueEnum");
+
+    public final static io.objectbox.Property<MetaLeaf> valueUnit =
+        new io.objectbox.Property<>(__INSTANCE, 6, 7, String.class, "valueUnit");
+
+    public final static io.objectbox.Property<MetaLeaf> valueMin =
+        new io.objectbox.Property<>(__INSTANCE, 7, 8, String.class, "valueMin");
+
+    public final static io.objectbox.Property<MetaLeaf> valueMax =
+        new io.objectbox.Property<>(__INSTANCE, 8, 9, String.class, "valueMax");
+
+    public final static io.objectbox.Property<MetaLeaf> branchId =
+        new io.objectbox.Property<>(__INSTANCE, 9, 10, long.class, "branchId", true);
+
+    @SuppressWarnings("unchecked")
+    public final static io.objectbox.Property<MetaLeaf>[] __ALL_PROPERTIES = new io.objectbox.Property[]{
+        id,
+        name,
+        description,
+        flags,
+        valueType,
+        valueEnum,
+        valueUnit,
+        valueMin,
+        valueMax,
+        branchId
+    };
+
+    public final static io.objectbox.Property<MetaLeaf> __ID_PROPERTY = id;
+
+    @Override
+    public String getEntityName() {
+        return __ENTITY_NAME;
+    }
+
+    @Override
+    public int getEntityId() {
+        return __ENTITY_ID;
+    }
+
+    @Override
+    public Class<MetaLeaf> getEntityClass() {
+        return __ENTITY_CLASS;
+    }
+
+    @Override
+    public String getDbName() {
+        return __DB_NAME;
+    }
+
+    @Override
+    public io.objectbox.Property<MetaLeaf>[] getAllProperties() {
+        return __ALL_PROPERTIES;
+    }
+
+    @Override
+    public io.objectbox.Property<MetaLeaf> getIdProperty() {
+        return __ID_PROPERTY;
+    }
+
+    @Override
+    public IdGetter<MetaLeaf> getIdGetter() {
+        return __ID_GETTER;
+    }
+
+    @Override
+    public CursorFactory<MetaLeaf> getCursorFactory() {
+        return __CURSOR_FACTORY;
+    }
+
+    @Internal
+    static final class MetaLeafIdGetter implements IdGetter<MetaLeaf> {
+        @Override
+        public long getId(MetaLeaf object) {
+            return object.getId();
+        }
+    }
+
+    /** To-one relation "branch" to target entity "MetaBranch". */
+    public static final RelationInfo<MetaLeaf, MetaBranch> branch =
+            new RelationInfo<>(MetaLeaf_.__INSTANCE, MetaBranch_.__INSTANCE, branchId, new ToOneGetter<MetaLeaf, MetaBranch>() {
+                @Override
+                public ToOne<MetaBranch> getToOne(MetaLeaf entity) {
+                    return entity.branch;
+                }
+            });
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MyTreeModel.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MyTreeModel.java
new file mode 100644
index 00000000..185d7585
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/MyTreeModel.java
@@ -0,0 +1,143 @@
+
+package io.objectbox.tree;
+
+import io.objectbox.BoxStoreBuilder;
+import io.objectbox.ModelBuilder;
+import io.objectbox.ModelBuilder.EntityBuilder;
+import io.objectbox.model.PropertyFlags;
+import io.objectbox.model.PropertyType;
+
+/**
+ * Tree-relevant model adapted from generated MyObjectBox of integration test project for.
+ */
+public class MyTreeModel {
+
+    public static BoxStoreBuilder builder() {
+        BoxStoreBuilder builder = new BoxStoreBuilder(getModel());
+        addTreeEntities(builder);
+        return builder;
+    }
+
+    public static void addTreeEntities(BoxStoreBuilder builder) {
+        builder.entity(DataBranch_.__INSTANCE);
+        builder.entity(MetaBranch_.__INSTANCE);
+        builder.entity(DataLeaf_.__INSTANCE);
+        builder.entity(MetaLeaf_.__INSTANCE);
+    }
+
+    private static byte[] getModel() {
+        ModelBuilder modelBuilder = new ModelBuilder();
+        addTreeModel(modelBuilder);
+        modelBuilder.lastEntityId(lastEntityId(),lastEntityUid());
+        modelBuilder.lastIndexId(lastIndexId(), lastIndexUid());
+        return modelBuilder.build();
+    }
+
+    private static void addTreeModel(ModelBuilder modelBuilder) {
+        buildEntityDataBranch(modelBuilder);
+        buildEntityMetaBranch(modelBuilder);
+        buildEntityDataLeaf(modelBuilder);
+        buildEntityMetaLeaf(modelBuilder);
+    }
+
+    private static void buildEntityDataBranch(ModelBuilder modelBuilder) {
+        EntityBuilder entityBuilder = modelBuilder.entity("DataBranch");
+        entityBuilder.id(44, 6392934887623369090L).lastPropertyId(4, 5493340424534667127L);
+        entityBuilder.flags(io.objectbox.model.EntityFlags.USE_NO_ARG_CONSTRUCTOR);
+
+        entityBuilder.property("id", PropertyType.Long).id(1, 6091686668168828751L)
+                .flags(PropertyFlags.ID);
+        entityBuilder.property("uid", PropertyType.String).id(2, 618590728777271608L)
+                .flags(PropertyFlags.INDEX_HASH | PropertyFlags.UNIQUE | PropertyFlags.UNIQUE_ON_CONFLICT_REPLACE).indexId(101, 2335075400716688517L);
+        entityBuilder.property("parentId", "DataBranch", "parent", PropertyType.Relation).id(3, 6451585858539687076L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.VIRTUAL | PropertyFlags.INDEXED | PropertyFlags.INDEX_PARTIAL_SKIP_ZERO).indexId(102, 5972614031084366599L);
+        entityBuilder.property("metaBranchId", "MetaBranch", "metaBranch", PropertyType.Relation).id(4, 5493340424534667127L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.VIRTUAL | PropertyFlags.INDEXED | PropertyFlags.INDEX_PARTIAL_SKIP_ZERO).indexId(103, 8201014180214634794L);
+
+
+        entityBuilder.entityDone();
+    }
+
+    private static void buildEntityMetaBranch(ModelBuilder modelBuilder) {
+        EntityBuilder entityBuilder = modelBuilder.entity("MetaBranch");
+        entityBuilder.id(45, 1310274875657521237L).lastPropertyId(4, 4595036309339359712L);
+        entityBuilder.flags(io.objectbox.model.EntityFlags.USE_NO_ARG_CONSTRUCTOR);
+
+        entityBuilder.property("id", PropertyType.Long).id(1, 1194261531523403259L)
+                .flags(PropertyFlags.ID);
+        entityBuilder.property("name", PropertyType.String).id(2, 2154298180099032522L);
+        entityBuilder.property("description", PropertyType.String).id(3, 7184740729497471956L);
+        entityBuilder.property("parentId", "MetaBranch", "parent", PropertyType.Relation).id(4, 4595036309339359712L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.VIRTUAL | PropertyFlags.INDEXED | PropertyFlags.INDEX_PARTIAL_SKIP_ZERO).indexId(104, 4816571718244293666L);
+
+
+        entityBuilder.entityDone();
+    }
+
+    private static void buildEntityDataLeaf(ModelBuilder modelBuilder) {
+        EntityBuilder entityBuilder = modelBuilder.entity("DataLeaf");
+        entityBuilder.id(46, 467861220182153395L).lastPropertyId(7, 4699140392024010132L);
+        entityBuilder.flags(io.objectbox.model.EntityFlags.USE_NO_ARG_CONSTRUCTOR);
+
+        entityBuilder.property("id", PropertyType.Long).id(1, 4828688333591497370L)
+                .flags(PropertyFlags.ID);
+        entityBuilder.property("valueInt", PropertyType.Long).id(2, 5680848072093066354L)
+                .flags(PropertyFlags.NOT_NULL);
+        entityBuilder.property("valueDouble", PropertyType.Double).id(3, 1807721889883579442L)
+                .flags(PropertyFlags.NOT_NULL);
+        entityBuilder.property("valueString", PropertyType.String).id(4, 3664314117089332414L);
+        entityBuilder.property("valueStrings", PropertyType.StringVector).id(5, 9123492271146452029L);
+        entityBuilder.property("dataBranchId", "DataBranch", "dataBranch", PropertyType.Relation).id(6, 8206794170110103204L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.VIRTUAL | PropertyFlags.INDEXED | PropertyFlags.INDEX_PARTIAL_SKIP_ZERO).indexId(105, 3957808210294196067L);
+        entityBuilder.property("metaLeafId", "MetaLeaf", "metaLeaf", PropertyType.Relation).id(7, 4699140392024010132L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.VIRTUAL | PropertyFlags.INDEXED | PropertyFlags.INDEX_PARTIAL_SKIP_ZERO).indexId(106, 977164625385952067L);
+
+
+        entityBuilder.entityDone();
+    }
+
+    private static void buildEntityMetaLeaf(ModelBuilder modelBuilder) {
+        EntityBuilder entityBuilder = modelBuilder.entity("MetaLeaf");
+        entityBuilder.id(47, 5254271311260799313L).lastPropertyId(10, 8664500113133909445L);
+        entityBuilder.flags(io.objectbox.model.EntityFlags.USE_NO_ARG_CONSTRUCTOR);
+
+        entityBuilder.property("id", PropertyType.Long).id(1, 3427494083756650716L)
+                .flags(PropertyFlags.ID);
+        entityBuilder.property("name", PropertyType.String).id(2, 5713619020507923508L);
+        entityBuilder.property("description", PropertyType.String).id(3, 5039668234383376989L);
+        entityBuilder.property("flags", PropertyType.Int).id(4, 5257477461658965421L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.UNSIGNED);
+        entityBuilder.property("valueType", PropertyType.Short).id(5, 7457766704836131009L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.UNSIGNED);
+        entityBuilder.property("valueEnum", PropertyType.StringVector).id(6, 1440153045496741290L);
+        entityBuilder.property("valueUnit", PropertyType.String).id(7, 8462205277100323490L);
+        entityBuilder.property("valueMin", PropertyType.String).id(8, 2892243010305059156L);
+        entityBuilder.property("valueMax", PropertyType.String).id(9, 2813620764730453795L);
+        entityBuilder.property("branchId", "MetaBranch", "branch", PropertyType.Relation).id(10, 8664500113133909445L)
+                .flags(PropertyFlags.NOT_NULL | PropertyFlags.VIRTUAL | PropertyFlags.INDEXED | PropertyFlags.INDEX_PARTIAL_SKIP_ZERO).indexId(107, 1337360598786750127L);
+
+
+        entityBuilder.entityDone();
+    }
+
+    // See buildEntityMetaLeaf()
+    static int lastEntityId() {
+        return 47;
+    }
+
+    // See buildEntityMetaLeaf()
+    static long lastEntityUid() {
+        return 5254271311260799313L;
+    }
+
+    // See buildEntityMetaLeaf()
+    static int lastIndexId() {
+        return 107;
+    }
+
+    // See buildEntityMetaLeaf()
+    static long lastIndexUid() {
+        return 1337360598786750127L;
+    }
+
+}
diff --git a/tests/objectbox-java-test/src/test/java/io/objectbox/tree/TreeTest.java b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/TreeTest.java
new file mode 100644
index 00000000..9fe37d56
--- /dev/null
+++ b/tests/objectbox-java-test/src/test/java/io/objectbox/tree/TreeTest.java
@@ -0,0 +1,280 @@
+package io.objectbox.tree;
+
+import io.objectbox.AbstractObjectBoxTest;
+import io.objectbox.BoxStore;
+import io.objectbox.model.PropertyType;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicLong;
+
+import static java.util.Objects.requireNonNull;
+import static org.junit.Assert.*;
+
+public class TreeTest extends AbstractObjectBoxTest {
+    private Tree tree;
+    private Branch root;
+    private long rootId;
+    private long[] metaBranchIds;
+
+    @Override
+    protected BoxStore createBoxStore() {
+        return MyTreeModel.builder().build();
+    }
+
+    @Before
+    public void createTree() {
+        Tree prepTree = new Tree(store, 0);
+        long rootId = prepTree.callInTxNoThrow(() -> {
+            metaBranchIds = prepTree.putMetaBranches(new String[]{"Library", "Book", "Author"});
+            return prepTree.putBranch(0, metaBranchIds[0]);  // Library data branch (data tree root)
+        });
+        tree = new Tree(store, rootId);
+        root = tree.getRoot();
+        this.rootId = root.getId();
+        assertNotEquals(0, this.rootId);
+        assertEquals(rootId, tree.getRootId());
+        assertEquals(3, metaBranchIds.length);
+    }
+
+    @Test(expected = IllegalStateException.class)
+    public void putWithoutTx() {
+        tree.putBranch(0, rootId, 0, null);
+    }
+
+    @Test
+    public void getNotFound() {
+        tree.runInReadTx(() -> {
+            assertNull(tree.getLeaf(42));
+            assertNull(tree.getString(42));
+            assertNull(tree.getInteger(42));
+            assertNull(tree.getDouble(42));
+        });
+    }
+
+    @Test
+    public void putAndGetValue() {
+        long[] intId = {0}, doubleId = {0}, stringId = {0};  // Use arrays to allow assigning inside lambda
+
+        // Note: this is somewhat in the gray zone as we do not set up corresponding a meta tree
+        tree.runInTx(() -> {
+            intId[0] = tree.putValue(0, rootId, 0, 42);
+            doubleId[0] = tree.putValue(0, rootId, 0, 3.141);
+            stringId[0] = tree.putValue(0, rootId, 0, "foo-tree");
+        });
+
+        assertNotEquals(0, intId[0]);
+        assertNotEquals(0, doubleId[0]);
+        assertNotEquals(0, stringId[0]);
+
+        tree.runInReadTx(() -> {
+            Leaf intLeaf = tree.getLeaf(intId[0]);
+            assertNotNull(intLeaf);
+            assertEquals(42, intLeaf.getInt());
+            assertTrue(intLeaf.isInt());
+            assertFalse(intLeaf.isDouble());
+            assertFalse(intLeaf.isString());
+            assertFalse(intLeaf.isStringArray());
+
+            assertEquals("42", intLeaf.asString());
+            assertEquals(42.0, requireNonNull(intLeaf.asDouble()), 0.0);
+            assertArrayEquals(new String[]{"42"}, intLeaf.asStringArray());
+
+            assertEquals(Long.valueOf(42), tree.getInteger(intId[0]));
+
+            assertEquals(3.141, requireNonNull(tree.getLeaf(doubleId[0])).getDouble(), 0.0);
+            assertEquals(Double.valueOf(3.141), tree.getDouble(doubleId[0]));
+
+            assertEquals("foo-tree", requireNonNull(tree.getLeaf(stringId[0])).getString());
+            assertEquals("foo-tree", tree.getString(stringId[0]));
+        });
+    }
+
+    @Test
+    public void treePath() {
+        long[] metaLeafIds = {0};
+
+        tree.runInTx(() -> {
+            // Meta
+            long metaNameId = tree.putMetaLeaf(0, metaBranchIds[2], "Name", PropertyType.String);
+            long metaYearId = tree.putMetaLeaf(0, metaBranchIds[2], "Year", PropertyType.Int);
+            long metaPriceId = tree.putMetaLeaf(0, metaBranchIds[2], "Height", PropertyType.Double);
+            assertNotEquals(0, metaNameId);
+            assertNotEquals(0, metaYearId);
+            assertNotEquals(0, metaPriceId);
+            metaLeafIds[0] = metaNameId;
+
+            // Data
+            long libraryId = rootId;
+            assertNotEquals(0, libraryId);
+            long bookId = tree.putBranch(libraryId, metaBranchIds[1]);
+            assertNotEquals(0, bookId);
+            long authorId = tree.putBranch(bookId, metaBranchIds[2]);
+            assertNotEquals(0, authorId);
+            tree.putValue(authorId, metaNameId, "Tolkien");
+            tree.putValue(authorId, metaYearId, 2021);
+            tree.putValue(authorId, metaPriceId, 12.34);
+
+            // 2nd meta branch off from "Book"
+            long[] metaBranchIds2 = tree.putMetaBranches(metaBranchIds[1], new String[]{"Publisher", "Company"});
+            assertEquals(2, metaBranchIds2.length);
+        });
+
+        tree.runInReadTx(() -> {
+            Branch book = root.branch("Book");
+            assertNotNull(book);
+            // get leaf indirectly by traversing branches
+            Branch author = book.branchChild("Author");
+            assertNotNull(author);
+
+            Leaf name = author.leafChild("Name");
+            assertNotNull(name);
+            assertEquals("Tolkien", name.getString());
+            assertFalse(name.isInt());
+            assertFalse(name.isDouble());
+            assertTrue(name.isString());
+            assertFalse(name.isStringArray());
+            assertNotEquals(0, name.getId());
+            assertEquals(author.getId(), name.getParentBranchId());
+            assertEquals(metaLeafIds[0], name.getMetaId());
+
+            Leaf year = author.leafChild("Year");
+            assertNotNull(year);
+            assertEquals(2021, year.getInt());
+
+            Leaf height = author.leafChild("Height");
+            assertNotNull(height);
+            assertEquals(12.34, height.getDouble(), 0.0);
+
+            // get leaf directly
+            Leaf name2 = book.leaf(new String[]{"Author", "Name"});
+            assertNotNull(name2);
+            assertEquals("Tolkien", name2.getString());
+
+            // get leaf directly via path string
+            name2 = book.leaf("Author.Name");
+            assertNotNull(name2);
+            assertEquals("Tolkien", name2.getString());
+
+            // get leaf directly via path string with another separator
+            assertNull(book.leaf("Author/Name"));
+            tree.setPathSeparatorRegex("\\/");
+            name2 = book.leaf("Author/Name");
+            assertNotNull(name2);
+            assertEquals("Tolkien", name2.getString());
+
+        });
+    }
+
+    @Test
+    public void putValueForExistingLeaf_String() {
+        tree.runInTx(() -> {
+            long metaNameId = tree.putMetaLeaf(0, metaBranchIds[0], "Name", PropertyType.String);
+            assertNotEquals(0, metaNameId);
+            tree.putValue(rootId, metaNameId, "Bookery");
+            Leaf leaf = root.leafChild("Name");
+            assertNotNull(leaf);
+            assertEquals("Bookery", leaf.getString());
+
+            assertThrows(IllegalStateException.class, () -> leaf.setInt(42));
+            assertThrows(IllegalStateException.class, () -> leaf.setDouble(3.141));
+            assertThrows(IllegalStateException.class, () -> leaf.setStringArray(new String[]{}));
+
+            leaf.setString("Unseen Library");
+            long idPut = tree.put(leaf);
+            assertEquals(leaf.getId(), idPut); // Unchanged
+        });
+
+        tree.runInReadTx(() -> {
+            Leaf name = root.leafChild("Name");
+            assertNotNull(name);
+            assertEquals("Unseen Library", name.getString());
+        });
+    }
+
+    @Test
+    public void putValueForExistingLeaf_Int() {
+        tree.runInTx(() -> {
+            long metaYearId = tree.putMetaLeaf(0, metaBranchIds[0], "Year", PropertyType.Int);
+            assertNotEquals(0, metaYearId);
+            tree.putValue(rootId, metaYearId, 1982);
+            Leaf leaf = root.leafChild("Year");
+            assertNotNull(leaf);
+            assertEquals(1982, leaf.getInt());
+
+            assertThrows(IllegalStateException.class, () -> leaf.setString("foo"));
+            assertThrows(IllegalStateException.class, () -> leaf.setDouble(3.141));
+            assertThrows(IllegalStateException.class, () -> leaf.setStringArray(new String[]{}));
+
+            leaf.setInt(1977);
+            long idPut = tree.put(leaf);
+            assertEquals(leaf.getId(), idPut); // Unchanged
+        });
+
+        tree.runInReadTx(() -> {
+            Leaf year = root.leafChild("Year");
+            assertNotNull(year);
+            assertEquals(1977, year.getInt());
+        });
+    }
+
+    @Test
+    public void concurrentTxs() throws InterruptedException {
+        final CountDownLatch latch = new CountDownLatch(3);
+        final AtomicBoolean readThreadOK = new AtomicBoolean(false);
+        final AtomicLong bookBranchId = new AtomicLong(0);
+        Thread readThread = new Thread(() -> {
+            tree.runInReadTx(() -> {
+                System.out.println("Thread " + Thread.currentThread().getId() + " entered tree TX");
+                latch.countDown();
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                assertNull(tree.getRoot().branchChild("Book"));
+                readThreadOK.set(true);
+            });
+        });
+        readThread.start();
+
+        Thread writeThread = new Thread(() -> {
+            tree.runInTx(() -> {
+                System.out.println("Thread " + Thread.currentThread().getId() + " entered tree TX (write)");
+                latch.countDown();
+                try {
+                    latch.await();
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
+                long id = tree.putBranch(tree.getRoot().getId(), metaBranchIds[1]);
+                bookBranchId.set(id);
+            });
+        });
+        writeThread.start();
+
+        Callable<Branch> branchCallable = () -> {
+            System.out.println("Thread " + Thread.currentThread().getId() + " entered tree TX");
+            latch.countDown();
+            latch.await();
+            return tree.getRoot().branchChild("Book");
+        };
+        Branch branch = tree.callInReadTx(branchCallable);
+        assertNull(branch);
+
+        // And once more to see that read TXs can still be started
+        tree.callInReadTx(branchCallable);
+
+        readThread.join();
+        assertTrue(readThreadOK.get());
+        writeThread.join();
+        assertNotEquals(0, bookBranchId.get());
+
+        branch = tree.callInReadTx(branchCallable);
+        assertNotNull(branch);
+        assertEquals(bookBranchId.get(), branch.getId());
+    }
+}
diff --git a/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-keysize0-data.mdb b/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-keysize0-data.mdb
new file mode 100644
index 00000000..7b9af7f7
Binary files /dev/null and b/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-keysize0-data.mdb differ
diff --git a/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-pageno-in-branch-data.mdb b/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-pageno-in-branch-data.mdb
new file mode 100644
index 00000000..db978297
Binary files /dev/null and b/tests/objectbox-java-test/src/test/resources/io/objectbox/corrupt-pageno-in-branch-data.mdb differ
diff --git a/tests/test-proguard/build.gradle b/tests/test-proguard/build.gradle
deleted file mode 100644
index 4052e9b4..00000000
--- a/tests/test-proguard/build.gradle
+++ /dev/null
@@ -1,37 +0,0 @@
-apply plugin: 'java-library'
-
-uploadArchives.enabled = false
-
-sourceCompatibility = JavaVersion.VERSION_1_8
-targetCompatibility = JavaVersion.VERSION_1_8
-
-repositories {
-    // Native lib might be deployed only in internal repo
-    if (project.hasProperty('internalObjectBoxRepo')) {
-        println "internalObjectBoxRepo=$internalObjectBoxRepo added to repositories."
-        maven {
-            credentials {
-                username internalObjectBoxRepoUser
-                password internalObjectBoxRepoPassword
-            }
-            url internalObjectBoxRepo
-        }
-    } else {
-        println "WARNING: Property internalObjectBoxRepo not set."
-    }
-}
-
-dependencies {
-    implementation project(':objectbox-java')
-    implementation project(':objectbox-java-api')
-
-    // Check flag to use locally compiled version to avoid dependency cycles
-    if (!project.hasProperty('noObjectBoxTestDepencies') || !noObjectBoxTestDepencies) {
-        println "Using $ob_native_dep"
-        implementation ob_native_dep
-    } else {
-        println "Did NOT add native dependency"
-    }
-
-    testImplementation "junit:junit:$junit_version"
-}
diff --git a/tests/test-proguard/build.gradle.kts b/tests/test-proguard/build.gradle.kts
new file mode 100644
index 00000000..1cfb27ac
--- /dev/null
+++ b/tests/test-proguard/build.gradle.kts
@@ -0,0 +1,20 @@
+plugins {
+    id("java-library")
+}
+
+tasks.withType<JavaCompile> {
+    // Note: use release flag instead of sourceCompatibility and targetCompatibility to ensure only JDK 8 API is used.
+    // https://docs.gradle.org/current/userguide/building_java_projects.html#sec:java_cross_compilation
+    options.release.set(8)
+}
+
+val versionDatabaseLibraryJvm: String by rootProject.extra
+
+dependencies {
+    implementation(project(":objectbox-java"))
+    implementation("io.objectbox:objectbox-linux:$versionDatabaseLibraryJvm")
+    implementation("io.objectbox:objectbox-macos:$versionDatabaseLibraryJvm")
+    implementation("io.objectbox:objectbox-windows:$versionDatabaseLibraryJvm")
+
+    testImplementation(libs.junit)
+}
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java
index c1da86fc..32c5ce77 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/MyObjectBox.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java
index 66670f20..eeaf26fd 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java
index 47ca99c9..6cd03c55 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntityCursor.java
@@ -1,5 +1,5 @@
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -48,7 +48,7 @@ public ObfuscatedEntityCursor(Transaction tx, long cursor, BoxStore boxStore) {
     }
 
     @Override
-    public final long getId(ObfuscatedEntity entity) {
+    public long getId(ObfuscatedEntity entity) {
         return ID_GETTER.getId(entity);
     }
 
@@ -58,7 +58,7 @@ public final long getId(ObfuscatedEntity entity) {
      * @return The ID of the object within its box.
      */
     @Override
-    public final long put(ObfuscatedEntity entity) {
+    public long put(ObfuscatedEntity entity) {
         String myString = entity.getMyString();
         int __id2 = myString != null ? __ID_myString : 0;
 
diff --git a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java
index 32c22eda..9fec4622 100644
--- a/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java
+++ b/tests/test-proguard/src/main/java/io/objectbox/test/proguard/ObfuscatedEntity_.java
@@ -1,6 +1,5 @@
-
 /*
- * Copyright 2017 ObjectBox Ltd. All rights reserved.
+ * Copyright 2017 ObjectBox Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.