objectbox/objectbox-dart

This system is the ObjectBox Dart and Flutter SDK, providing an embedded, high-performance NoSQL database with native bindings for mobile and desktop platforms. It includes a code generator that creates type-safe Dart models from annotations, supporting complex features like vector search, schema migrations, and relational data. The SDK also offers Mesh Sync for peer-to-peer synchronization and bundles platform-specific native libraries for Android, iOS, Linux, macOS, and Windows.

19 changes.

This period established the foundational repository structure for the ObjectBox Dart/Flutter SDK, introducing the core runtime, code generator, and Flutter plugins. The code generator was refactored into modular components with configurable outputs, while integration tests were expanded to verify schema evolution and property handling. Concurrently, platform-specific Flutter plugins for native libraries and Mesh Sync were initialized to support Android and iOS environments.

27 changes.

This period focused on extending ObjectBox Flutter support to Linux and Windows desktop platforms while updating native bindings to C API version 6.0.0. The team also introduced comprehensive performance benchmarking tools and expanded integration tests to validate complex relations and code generation scenarios.

19 changes.

This period focused on expanding the ObjectBox Flutter ecosystem by adding comprehensive platform support for macOS and Windows to existing examples, alongside introducing new demos for relations and many-to-many relationships. Concurrently, the code generator was enhanced with anonymous usage analytics, and the Android Sync plugin was updated to handle mesh network creation with runtime permissions. The work was grounded by significant expansions in test coverage for both the core Dart library and the code generator to ensure stability across these new features and platforms.

11 changes.

This period focused on enhancing ObjectBox's capabilities with on-device vector search examples for geographic data and refining synthetic property annotation support. Concurrently, significant effort was directed toward expanding test coverage by adding iOS and macOS test scaffolds for Flutter demos and establishing a dedicated Android test application for integration testing sync behaviors.

A new example application demonstrating on-device vector search using ObjectBox in Dart has been added. The \vectorsearch\_cities\ project includes a main script that queries the database for the two closest city neighbors by ID and full object, along with standard Dart project configuration files (analysis options, gitignore) and documentation linking to the on-device ANN vector search guide.

objectbox/example/dart-native · high confidence

New CMakeLists.txt, header, and source files have been added to the linux directories for both the objectbox\_flutter\_libs and objectbox\_sync\_flutter\_libs plugins. These files enable Flutter desktop builds on Linux by configuring CMake 3.14+ to automatically download the corresponding prebuilt ObjectBox C libraries (version 6.0.0-beta) for x86\_64, ARM64/ARMv8, ARMv7, and ARMv6 architectures via FetchContent. The plugins are set up to bundle these libraries without directly linking them, allowing the Dart layer to locate them in the standard lib subfolder during the build process.

_flutter\_libs/linux, sync\_flutter\libs/linux · high confidence

The relations demo application now includes a Linux desktop target, enabling users to run the example on Linux systems. This change adds the necessary CMake build configuration, GTK-based native runner code, and Flutter plugin registration (specifically for the ObjectBox Flutter libraries) required to build and execute the demo on the Linux platform.

_objectbox/example/flutter/objectbox\_demo/linux, objectbox/example/flutter/objectbox\_demo\relations/linux · high confidence

The \flutter\_libs\ and \sync\_flutter\_libs\ plugins now include Windows-specific build configurations (CMakeLists.txt) and plugin registration code, enabling ObjectBox to run on Windows desktop applications. The build scripts automatically download and bundle the corresponding Object-C native libraries (version 6.0.0-beta) for x64 architectures, ensuring the native dependencies are available at build time without manual setup.

_flutter\_libs/windows, sync\_flutter\libs/windows · high confidence

The Windows platform support for the objectbox\_demo\_relations Flutter example has been added. This includes the native C++ runner code (main entry point, window management, and Flutter view hosting), build configuration via CMake, and necessary resource files (manifest, icon, version info), enabling the relations demo to be built and run on Windows.

_objectbox/example/flutter/objectbox\_demo\relations/windows/runner · high confidence

The sync\_flutter\_libs plugin now supports iOS, enabling users to run ObjectBox sync functionality on iOS devices. This change introduces the necessary iOS plugin structure, including a Swift plugin class (ObjectboxSyncFlutterLibsPlugin) and associated configuration files, allowing the library to be integrated into iOS Flutter applications.

_sync\_flutter\libs/ios · high confidence

The macOS Xcode project files for the \objectbox\_demo\_relations\ Flutter example have been added, enabling the demo to be built and run on macOS. This includes the project configuration (\project.pbxproj\), workspace settings, and the Xcode scheme, which configures the build to prepare the Flutter framework and run the \objectbox\_demo\_relations.app\ target.

_objectbox/example/flutter/objectbox\_demo\relations/macos/Runner.xcodeproj · high confidence

The relations demo now runs on macOS. This change adds the native macOS Runner project (AppDelegate, window controller, menu, and assets) and configures the app-sandbox and application-group entitlements (group: objectbox.demo) required for the example to function correctly on the platform.

_objectbox/example/flutter/objectbox\_demo\relations/macos/Runner · high confidence

Added a new benchmarking tooling suite in \benchmark/lib\ to measure CRUD performance. This includes a \Benchmark\ class that handles warm-up (100ms) and stable measurement (2s) phases, reporting metrics like iterations per second and time per unit. It also introduces a \TestEntity\ model with string, int, long, and double properties, along with the corresponding ObjectBox model configuration, to serve as the data subject for these micro-benchmarks.

benchmark/lib · high confidence

The vectorsearch\_cities example now demonstrates geographic vector search by introducing a City model with a location property indexed via HnswIndex using the new Geo distance type. The example includes sample data for Barcelona, Nairobi, and Salzburg, and provides methods to query the two closest neighbors to Madrid using nearest-neighbor search on these geographic coordinates.

_objectbox/example/dart-native/vectorsearch\cities · high confidence

The Flutter relations demo example now includes the necessary Xcode workspace structure for iOS and macOS platforms. This adds the \Runner.xcworkspace\ containers, including the workspace data file linking to the project, the \IDEWorkspaceChecks.plist\ to suppress 32-bit warnings, and the \WorkspaceSettings.xcsettings\ with previews disabled, ensuring the example builds correctly on Apple platforms.

_objectbox/example/flutter/objectbox\_demo\_relations/ios/Runner.xcworkspace, objectbox/example/flutter/objectbox\_demo\relations/macos/Runner.xcworkspace · high confidence

The iOS native project files for the ObjectBox Relations Flutter example have been added, providing the standard iOS application entry point and configuration. This includes the AppDelegate implementing the implicit engine delegate pattern, a SceneDelegate for scene management, and the necessary Info.plist, storyboards, and asset catalogs to support the app on iPhone and iPad.

_objectbox/example/flutter/objectbox\_demo\relations/ios/Runner · high confidence

The macOS platform support for the ObjectBox relations demo application has been initialized. This includes the standard Flutter configuration files (Flutter-Debug.xcconfig and Flutter-Release.xcconfig) and the GeneratedPluginRegistrant.swift file, which explicitly registers the ObjectboxFlutterLibsPlugin to enable ObjectBox functionality on macOS.

_objectbox/example/flutter/objectbox\_demo\relations/macos/Flutter · high confidence

The macOS Flutter project now includes generated plugin registration files, enabling the ObjectBox library to function on desktop. This change adds the necessary configuration files (Flutter-Debug.xcconfig, Flutter-Release.xcconfig) and the GeneratedPluginRegistrant.swift file, which explicitly registers the ObjectboxFlutterLibsPlugin with the Flutter plugin registry.

_objectbox/example/flutter/objectbox\demo/macos/Flutter · high confidence

The Android plugin for ObjectBox Sync Flutter Libraries has been updated to expose a \createMeshNetwork\ platform method. This allows the Flutter app to initialize a Nearby Mesh Network on Android, automatically requesting necessary runtime permissions (such as location or nearby devices) before creation. If permissions are granted, the plugin notifies the Dart side to retry network initialization, ensuring the mesh sync functionality works correctly on modern Android versions without requiring manual permission management from the app developer.

_sync\_flutter\libs/android/src/main/kotlin · high confidence

The event management tutorial now includes a 'many\_to\_many' example that extends the base application to demonstrate many-to-many relationships. This version introduces a new Owner entity and allows tasks to be assigned to multiple owners via a dedicated selection screen (OwnerList). The UI components have been updated to support this multi-owner assignment, and the underlying ObjectBox model and store logic have been adjusted to manage the new relationships.

_objectbox/example/flutter/event\_management\_tutorial/many\_to\many · high confidence

This change introduces the \objectbox\_demo\ Flutter application, providing a complete example of integrating ObjectBox with a Flutter UI. The app features a note-taking interface where users can add and remove notes, with data persisted via ObjectBox. Key implementation details include initializing the ObjectBox store asynchronously in \main.dart\, populating the database with demo data if it is empty, and using a reactive query stream (\watch\) to update the UI in real-time as notes change. The demo also configures platform-specific storage paths and includes necessary project configuration files like \.gitignore\, \analysis\_options.yaml\, and the ObjectBox model definition.

_objectbox/example/flutter/objectbox\demo · high confidence

The library now exposes its core public API through the \objectbox/lib/src\ directory, introducing a structured set of Dart files that serve as the public interface for the ObjectBox database. This includes the \annotations.dart\ file defining \@Entity\ and \@Property\ annotations (with support for \realClass\ and \signed\ properties), the \common.dart\ file establishing a comprehensive exception hierarchy (\ObjectBoxException\, \StorageException\, \DbFullException\, \UniqueViolationException\, etc.), and the \transaction.dart\ file defining the \TxMode\ enum for read/write transaction control. Additionally, \store.dart\ and \sync.dart\ are introduced to manage store lifecycle and synchronization, while web-specific stubs are added to \web/\ directories to conditionally export native implementations, ensuring the package does not yet claim full web support on pub.dev.

objectbox/lib/src · high confidence

This change introduces the \sync\_flutter\_libs\ Flutter plugin, which bundles the native ObjectBox database library with the Mesh Sync client. The plugin provides the \createMeshConfig()\ API to configure Mesh Sync, automatically requesting necessary Android runtime permissions (such as Bluetooth and Nearby Wi-Fi) by default, though this behavior can be disabled. It also includes updated Flutter plugin templates and dependency overrides to support local development of the ObjectBox package.

_sync\_flutter\libs · high confidence

Establishes the foundational repository layout for the ObjectBox Dart/Flutter SDK, including the core \objectbox\ runtime, \generator\ package, and test suites. Introduces GitLab CI pipelines to automate code analysis, formatting, and unit tests across supported Dart SDK versions, alongside documentation guidelines for contributors and AI agents.

(repo-wide) · high confidence

Adds a new Flutter example application demonstrating how to use ObjectBox relations in a task-list app. The demo includes a data model with Task and Tag entities linked by a ToOne relation, a UI for creating, editing, and deleting tasks and tags, and a task list that updates via watched query streams. It also shows how to initialize the ObjectBox store, enable the ObjectBox Admin debug tool, and handle basic error cases in the data stream.

_objectbox/example/flutter/objectbox\_demo\relations · high confidence

A new entry point file (generator/lib/objectbox\_generator.dart) is added, exposing two builders: EntityResolverFactory, which finds classes annotated with @Entity and creates intermediate files, and CodeGeneratorFactory, which writes objectbox\_model.dart and objectbox-model.json from the prepared .objectbox.info files. This establishes the generator's public API for Dart/Flutter code generation.

generator/lib · high confidence

Queries can now be reused efficiently by setting parameters via the new \Query.param()\ API, allowing callers to update condition values (such as strings, integers, doubles, and byte vectors) without rebuilding the query object. Additionally, the \Query.property()\ method now returns a \PropertyQuery\ that supports aggregation operations like \count()\, \min()\, \max()\, \sum()\, and \average()\ on specific entity fields, enabling direct statistical analysis without fetching full entity objects.

objectbox/lib/src/native/query · high confidence

The new \objectbox\_sync\_flutter\_libs\ package provides platform-specific support for Mesh Sync on Flutter Android, including a \createMeshConfig\ function that automatically requests necessary runtime permissions and manages the Nearby mesh network lifecycle. This entry point allows developers to initialize mesh sync on Android by passing a mesh ID and optional callbacks, while explicitly throwing an \UnsupportedError\ for iOS and macOS platforms where the required native C APIs are not yet available in the Flutter bindings.

_sync\_flutter\libs/lib · high confidence

A new \objectbox\_flutter\_libs\ package has been added to provide platform-specific native library support for Flutter. It includes a \defaultStoreDirectory()\ function that returns the default database directory within the app's application documents directory, with a note advising desktop users to create a specific app directory instead. The package also sets up a method channel for future use.

_flutter\libs/lib · high confidence

A new Flutter-based test application named \objectbox\_test\_app\ has been introduced to facilitate running integration tests, specifically targeting the Android platform. This standalone directory contains the necessary entity definitions (\TestEntity\, \TestEntitySynced\, \TestEntityPrecedence\) and ObjectBox model configuration required for testing sync clock and precedence behaviors, along with a README providing instructions for executing these integration tests on an Android emulator.

_objectbox\_test\app · high confidence

The generator now collects anonymous usage data to help understand how the tool is used. This feature sends a single event per day per user to Mixpanel, capturing details such as the generator version, Dart and Flutter presence, operating system, and locale. The implementation uses the pointycastle library for secure token handling and includes a 10-second timeout for network requests to prevent build stalls, ensuring that analytics failures do not break the build process.

generator/lib/src/analysis · high confidence

Added a suite of new micro-benchmarks in the benchmark/bin directory to measure and compare the performance of core ObjectBox operations. These include benchmarks for basic model initialization and dynamic library loading, box access strategies (Map vs. HashMap vs. List), native pointer handling (asTypedList vs. memcpy), observer setup efficiency (watch vs. entityChanges), query execution (find, findIds, streams), and read/write operations (get, put, putAsync, putQueued, transactions). This allows users to track performance characteristics of these specific API calls and data access patterns.

benchmark/bin · high confidence

The repository now includes a suite of new shell scripts in the tool/ directory to streamline development and release workflows. These scripts automate setting package versions across Dart and Flutter projects (set-version.sh, set-android-version.sh, set-swift-version.sh, set-c-version.sh), handle the publishing process to pub.dev with dependency ordering and link updates (publish.sh, pubdev-links.sh), and support CI tasks such as downloading the sync-server executable (download-server.sh) and testing released versions (release-test.sh). Additional utilities include an initialization script for setting up packages and generating code (init.sh), a helper for updating Flutter plugin scaffolding (plugin-update.sh), and a common library for cross-platform compatibility (common.sh).

tool · high confidence

The generator now reads annotations placed on getter methods when processing getter/setter pairs that create synthetic fields. This allows users to customize property behavior directly on the getter, such as changing the property type with @Property, adding indexes with @Index, or excluding the property entirely with @Transient.

generator/integration-tests/getters · high confidence

The Android portion of the objectbox\_test\_app has been initialized with a standard Flutter V2 embedding setup. This includes a Kotlin-based MainActivity, AndroidManifest files declaring permissions for Wi-Fi, Bluetooth, and location (required for Mesh Sync's Nearby transport), and resource files defining light and dark theme launch styles. The project is configured to use Gradle 9.1.0.

_objectbox\_test\app/android · high confidence

The iOS Xcode project files for the ObjectBox Relations Flutter demo have been added, including the project configuration, workspace settings, and build scheme. This enables the demo application to be built and run on iOS devices and simulators.

_objectbox/example/flutter/objectbox\_demo\relations/ios/Runner.xcodeproj · high confidence

The generator package has been restructured and prepared for publishing, including the addition of a CHANGELOG, LICENSE, and README. The build configuration (build.yaml) defines two builders: a resolver that creates intermediate .objectbox.info files and a generator that produces objectbox.g.dart. Analysis options now include the lints/recommended set and exclude integration tests. A test.sh script and pubspec\_overrides.yaml are included to support local development and integration testing.

generator · high confidence

The ToOne and ToMany relation classes now support initialization via their constructors, allowing users to set the target object (for ToOne) or a list of items (for ToMany) directly when creating the relation instance, which is useful for initializing objects from external sources like JSON. Additionally, these relation classes now include internal store configuration wrappers to support sending relations across isolates, as Dart isolates cannot directly send Store pointers. The ToOne class also introduces a detach-like mechanism via store configuration handling to manage lifecycle across isolates.

objectbox/lib/src/relations · high confidence

The iOS project files for the event management and many-to-many tutorial examples have been regenerated to require iOS 15 and adopt the modern Flutter plugin structure. This includes adding a SceneDelegate for scene management, updating the AppDelegate to use the implicit engine delegate, and removing CocoaPods dependencies in favor of the new plugin registration mechanism.

_objectbox/example/flutter/event\_management\_tutorial/event\_manager/ios, objectbox/example/flutter/event\_management\_tutorial/many\_to\many/ios · high confidence

The Android side of the ObjectBox Flutter plugin has been refactored to align with the Flutter SDK 3.29.3 template. This includes updating the package name to \io.objectbox.objectbox\_flutter\_libs\, restructuring the Kotlin plugin class (\ObjectboxFlutterLibsPlugin\) to follow current embedding conventions, and adding standard build artifacts to \.gitignore\. These changes ensure the plugin remains compatible with modern Flutter tooling and build processes.

_flutter\libs/android · high confidence

The flutter\_libs package has been updated to align with the Flutter SDK 3.29.3 and 3.44 templates, including the addition of standard Flutter plugin files such as .gitignore, .metadata, and analysis\_options.yaml. A pubspec\_overrides.yaml file has been introduced to facilitate local development by overriding the objectbox dependency to use the local repository path, while the README and CHANGELOG have been refreshed to clarify the package's role as a Flutter plugin for the ObjectBox database.

_flutter\libs · medium confidence

The code generator has been refactored from a monolithic structure into distinct, focused components: \EntityResolver\ handles annotation scanning, \CodeBuilder\ orchestrates the build process and model merging, and \CodeChunks\ manages the generation of Dart source code. This change introduces a new \Config\ class that allows users to customize the output directory for generated code via \pubspec.yaml\ (supporting separate paths for \lib\ and \test\ directories), and adds a \.gitignore\ file to exclude internal analysis tokens from version control while ensuring they are published to pub.dev for correct analysis.

generator/lib/src · high confidence

The iOS and macOS example projects now include explicit workspace configuration files. This adds the standard workspace data file, enables the 32-bit warning check, and disables previews for the iOS workspace, ensuring consistent Xcode workspace settings for the ObjectBox Flutter demo on Apple platforms.

_objectbox/example/flutter/objectbox\_demo/ios/Runner.xcworkspace, objectbox/example/flutter/objectbox\demo/macos/Runner.xcworkspace · high confidence

The native Dart layer has been restructured into a new set of source files under \objectbox/lib/src/native/\. This includes \admin.dart\ for the local database browser, \box.dart\ with asynchronous write methods (\putAsync\, \putAndGetAsync\), \model.dart\ for entity schema handling, \observable.dart\ for change streams, \store.dart\ for core database management, \sync.dart\ and \sync\_mesh.dart\ for server and peer-to-peer synchronization, and \transaction.dart\ for transaction management. These files provide the FFI bindings and Dart-side logic for the ObjectBox runtime.

objectbox/lib/src/native · high confidence

Added three new shell scripts to the tool directory to support CI workflows: build-example.sh automates building Flutter examples (including App Bundle, iOS, macOS, Linux, and Windows builds), common.sh provides a shared utility for determining the repository root, and coverage.sh generates LCOV code coverage reports for the ObjectBox library by formatting test coverage data and excluding specific native files.

objectbox/tool · high confidence

The Android configuration for the ObjectBox relations demo has been updated to align with modern Flutter standards. The Gradle wrapper has been upgraded to version 9.1.0 (as shown in gradle-wrapper.properties), and the AndroidManifest.xml files have been regenerated to use the standard Flutter V2 embedding, include the required INTERNET permission for development, and add the necessary queries for text processing support. Additionally, the project now uses Kotlin for the MainActivity and includes updated launch themes and splash screen drawables.

_objectbox/example/flutter/objectbox\_demo\relations/android · high confidence

The generator's integration tests have been moved from \generator/test\ to \generator/integration-tests\ to resolve dependency issues during publishing. This change introduces a new test infrastructure including a \test.sh\ runner, shared test utilities in \common.dart\ and \test\_env.dart\, and a \.gitignore\ to preserve native libraries. The new setup allows tests to run as isolated Dart packages, supporting sequential test files and pre-generation steps, while ensuring unique UIDs and correct model bindings are validated.

generator/integration-tests · high confidence

The internal model metadata representation has been reorganized into a dedicated \modelinfo\ directory, introducing specific classes for entities, properties, relations, and backlinks. This change adds support for HNSW vector search parameters via \ModelHnswParams\, introduces a \GeneratorVersion\ enum to enforce compatible generated sources, and adds new property flags for sync clocks and precedence. It also updates the model JSON schema to include external names and types for entities, properties, and relations, and refactors ID/UID handling into a dedicated \IdUid\ class.

objectbox/lib/src/modelinfo · high confidence

The library's public surface has been reorganized: \objectbox.dart\ now serves as the single entry point, explicitly exporting core components like \Box\, \Query\, \Store\, \Sync\, and \MeshSync\, while previously public internals (such as \modelinfo\, \flatbuffers\_readers\, and internal accessors) have been moved to a new \internal.dart\ library. This change hides implementation details from user code, ensuring that generated code and tools use the internal entry point while application code relies on the curated public exports.

objectbox/lib · high confidence

The Android and Linux platform configurations for the event management tutorial examples have been updated to align with Flutter SDK 3.44. On Android, the project now uses Gradle 9.1.0, includes the required INTERNET permission for development tools, and registers the ObjectboxFlutterLibs plugin via the standard V2 embedding. On Linux, the CMake build system has been updated to use GTK 3.0 and correctly registers the ObjectboxFlutterLibs plugin, ensuring the application builds and runs correctly on the desktop.

_objectbox/example/flutter/event\_management\_tutorial/event\_manager/android, objectbox/example/flutter/event\_management\_tutorial/event\_manager/linux, objectbox/example/flutter/event\_management\_tutorial/many\_to\many/android · high confidence

The Android configuration files for the objectbox\_demo have been regenerated to align with the current Flutter project template. This update includes a new .gitignore file that properly excludes build artifacts and keystore files, updated AndroidManifest.xml files for debug and profile builds that explicitly request the INTERNET permission, and a main manifest configured for the Flutter V2 embedding with a queries block for text processing support. The Kotlin MainActivity now extends FlutterActivity, and the launch themes and backgrounds have been refreshed to support both light and dark modes using the standard Flutter styling.

_objectbox/example/flutter/objectbox\demo/android · high confidence

The native bindings in \objectbox/lib/src/native/bindings\ have been updated to support the ObjectBox C API version 6.0.0 (headers \objectbox.h\ and \objectbox-sync.h\ now define \OBX\_VERSION\_MAJOR\ as 6). The \bindings.dart\ loader now enforces a minimum C API version of 5.3.2 and a minimum database version of 5.3.2-2026-05-05, rejecting libraries that do not meet these requirements. Additionally, the version check logic has been hardened to throw an error if the version string format is unrecognized, and the library loading mechanism now prefers checking for the \obx\_version\ symbol via \DynamicLibrary.process()\ before falling back to file-based loading.

objectbox/lib/src/native/bindings · high confidence

The Windows build artifacts for the objectbox\_demo\_relations example have been regenerated to align with newer Flutter SDK standards. This includes a new CMakeLists.txt that configures the Flutter library and C++ wrappers, alongside generated plugin registrant files that explicitly register the objectbox\_flutter\_libs plugin and the jni FFI plugin, ensuring the demo correctly links and initializes these dependencies on Windows.

_objectbox/example/flutter/objectbox\_demo/windows/flutter, objectbox/example/flutter/objectbox\_demo\relations/windows/flutter · high confidence

The Windows project files for the event management tutorial have been regenerated to align with the Flutter SDK 3.44 tooling. This update refreshes the CMake build configuration, the generated plugin registrant (registering the ObjectboxFlutterLibs plugin), and the native Windows runner code, ensuring the example builds and runs correctly on Windows with the latest Flutter version.

_objectbox/example/flutter/event\_management\_tutorial/event\_manager/windows, objectbox/example/flutter/event\_management\_tutorial/many\_to\many/windows · high confidence

The Windows runner directory for the objectbox\_demo Flutter example has been regenerated to match the current Flutter SDK template. This update includes new CMake build configuration, C++ source files for window management and plugin registration, and resource scripts that embed application metadata (such as versioning and DPI awareness). For users, this ensures the Windows build process remains compatible with modern Flutter tooling and correctly handles high-DPI displays and system themes.

_objectbox/example/flutter/objectbox\demo/windows/runner · medium confidence

The iOS Runner project files have been regenerated to align with the Flutter SDK 3.44.1 tooling. This update introduces a new project structure that includes a dedicated RunnerTests target for unit testing, integrates the FlutterGeneratedPluginSwiftPackage as a framework dependency, and updates the Xcode scheme to include a pre-action script for preparing the Flutter framework. These changes ensure the demo app builds correctly with the upgraded Flutter version and supports modern plugin registration and testing workflows.

_objectbox/example/flutter/objectbox\demo/ios/Runner.xcodeproj · high confidence

The iOS build configuration for the ObjectBox Flutter relations demo has been updated to require a minimum OS version of 15.0. This change, reflected in the newly generated AppFrameworkInfo.plist and associated Xcode configuration files, ensures the example app is built against modern iOS standards and aligns with the current Flutter SDK requirements.

_objectbox/example/flutter/objectbox\_demo\relations/ios/Flutter · high confidence

The macOS project files for the Event Management tutorial have been regenerated to support Flutter SDK 3.44. This update includes a new GeneratedPluginRegistrant.swift that explicitly registers the ObjectboxFlutterLibsPlugin, ensuring the database library is correctly initialized on macOS. The Xcode project configuration has been updated to use the FlutterGeneratedPluginSwiftPackage, and entitlements have been configured with the 'objectbox.demo' application group to enable shared data access. Additionally, the app bundle identifier is set to com.example.eventManagerObjectbox, and the project now includes a basic test target.

_objectbox/example/flutter/event\_management\_tutorial/event\_manager/macos, objectbox/example/flutter/event\_management\_tutorial/many\_to\many/macos · high confidence

The macOS demo application's Xcode project files have been regenerated to align with the Flutter SDK 3.16.9 upgrade. This update refreshes the project configuration, including the build scheme and workspace settings, ensuring compatibility with the newer Flutter tooling and maintaining the demo's ability to build and run on macOS.

_objectbox/example/flutter/objectbox\demo/macos/Runner.xcodeproj · high confidence

The macOS plugin source files for both the ObjectBox Flutter and Sync libraries have been updated to align with the Flutter SDK 3.44 template. This change ensures the plugin registration and method channel handling code follows the current framework standards, maintaining compatibility with newer Flutter versions on macOS.

_flutter\_libs/macos, sync\_flutter\libs/macos · low confidence

The iOS native runner files for the Objectbox Demo have been regenerated to match the Flutter 3.3.10 project template. This update introduces the modern iOS 13+ scene lifecycle by adding a SceneDelegate and configuring the app to use UIWindowScene in Info.plist, while also updating the AppDelegate to implement the FlutterImplicitEngineDelegate protocol for implicit engine initialization. Standard asset catalogs for app icons and launch screens, along with the corresponding storyboards, have been refreshed to align with the new template structure.

_objectbox/example/flutter/objectbox\demo/ios/Runner · high confidence

The iOS project files for the ObjectBox Flutter demo have been regenerated to align with the Flutter SDK 3.16.9 upgrade. This update sets the minimum supported iOS version to 15.0, as defined in the new AppFrameworkInfo.plist, and introduces standard Flutter-generated configuration files (Debug.xcconfig and Release.xcconfig) to manage build settings.

_objectbox/example/flutter/objectbox\demo/ios/Flutter · high confidence

The iOS implementation for the ObjectBox Flutter plugin has been restructured to align with the latest Flutter SDK templates (versions 3.29.3 and 3.44). This includes adding a \.gitignore\ file to exclude generated build artifacts and ephemeral files, creating an \Assets\ directory placeholder, and updating the Swift plugin source file (\ObjectboxFlutterLibsPlugin.swift\) to follow the standard \FlutterPlugin\ interface. These changes ensure the plugin's iOS project structure remains compatible with current Flutter tooling and build processes.

_flutter\libs/ios · high confidence

The macOS Runner configuration has been updated to include the \com.apple.security.application-groups\ entitlement with the group identifier \objectbox.demo\. This change enables the demo application to access shared containers, which is required to resolve write errors on macOS that occurred when this setting was missing.

_objectbox/example/flutter/objectbox\demo/macos/Runner · high confidence

Add integration test for index and unique property flags; Added iOS Runner test stub for the relations demo; Added iOS unit test scaffold for the ObjectBox Flutter demo; Added integration test for custom generator output configuration; Added integration tests for Admin and Sync features; Added integration tests for complex relation scenarios; Added integration tests for model migration scenarios; Added macOS Runner test scaffold for Relations demo; Added macOS test scaffold for ObjectBox Flutter demo; Added unit tests for the code generator and analysis components; Expanded test coverage for ObjectBox Dart core features; Integration test for ObjectBox with json\_serializable and freezed; Integration tests added for final fields and ID assignment behavior; Updated integration tests to verify new generator capabilities.

The Android build system for the ObjectBox Flutter demo has been updated to use Gradle 9.1.0. This ensures the project uses the latest build tooling specified in the wrapper configuration.

_objectbox/example/flutter/objectbox\demo/android/gradle · high confidence

This release updates the core ObjectBox Dart packages (\objectbox\, \objectbox\_generator\, \objectbox\_flutter\_libs\, and \sync\_flutter\_libs\) to version 6.0.0-beta. It upgrades the minimum supported Dart SDK to 3.7.0 for the generator and benchmark packages, and aligns Flutter examples with the Flutter 3.44.0 template. The Android build configuration has been updated to use Gradle 9.0.1 and Kotlin 2.3.20, while the iOS/macOS libraries now depend on ObjectBox Swift 5.3.0. Additionally, the generator's dependencies have been tightened to require \analyzer\ \>=8.1.1, \build\ \>=4.0.0, and \source\_gen\ ^4.0.1 to support newer Dart language features and build APIs.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• First survey — no prior run to compare against. CAI 66.

• Code Health 92
• Architecture 94
• Maturity 65
• Readiness 77
• Security 58
• Domain Modelling 78

• 300 commits — 281 feature/other, 19 fixes

• objectbox/lib — 53 commits
• objectbox/example — 40 commits
• objectbox/CHANGELOG.md — 36 commits
• .github/workflows — 29 commits
• (root) — 23 commits
• objectbox_test/test — 18 commits
• dev-doc/updating-c-library.md — 15 commits
• generator/test — 13 commits
• (repo) — 9 commits
• objectbox/README.md — 8 commits
• sync_flutter_libs/android — 8 commits
• generator/lib — 4 commits
• flutter_libs/android — 3 commits
• generator/pubspec.yaml — 3 commits
• objectbox/tool — 3 commits
• objectbox_test/android_runner — 3 commits
• tool/update-c-binding.sh — 3 commits
• benchmark/bin — 2 commits
• flutter_libs/linux — 2 commits
• objectbox_test_app/android — 2 commits

• fix: Fix ExternalPropertyType uuidString, uuidV4, uuidV4String throwing
• fix: Fix Store.attach lifecycle gaps; harden close and ctor error paths
• fix: Fix database version check rejecting compatible two-digit versions
• fix: Fix removeEntity not retiring relation and index UIDs
• fix: Fix setting list parameters on Date and DateNano properties
• fix: Fix watch() resume creating a new subscription instead of resuming
• fix: Fix withNativeStrings freeing uninitialized pointers on error
• fix: Guard QueryBuilder against use after build(); fix builder leaks
• fix: Merge branch 'generic-fixes'
• fix: Mesh (docs): fix arg name, add docs link in Flutter package README
• fix: Mesh (tests): add unit tests run during regular CI jobs, fixes coverage
• fix: Query set param fix: user-centric changelog, move test next to related
• fix: Query watch: write resume fix changelog entry more user-centric
• fix: READMEs: update copyright year, fix badges, update contact link
• fix: Tests (coverage): use Sync library, fix percentage value regex on CI
• fix: Tooling: fix silent failure modes in shell scripts
• fix: Validate store in ToMany.applyToDb; fix store leak in lazy load
• fix: release-test.sh: fix URL, make examples command
• fix: update-c-binding.sh: --clang-fix option added for ffigen compilation
• change: 6.0.0-beta release
• …and 280 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

objectbox/objectbox-dart was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.