MobileNativeFoundation/Store

This system is a Kotlin Multiplatform library designed for managing local data storage and synchronization across Android, iOS, JVM, JS, and Wasm targets. It provides a unified API for caching, fetching, and mutating data, featuring a new Store 5 interface with conflict resolution and a multi-cache strategy for handling both single items and collections. The library supports reactive programming through RxJava 2 adapters and includes a robust multicaster for managing data streams with race-condition fixes.

10 changes.

The project initialized version 5.1.0-beta01, introducing the new Store 5 API with MutableStore, conflict resolution, and multiplatform support for Android, iOS, JVM, JS, and Wasm JS. This release involved a comprehensive build system modernization to Gradle Version Catalogs and Kotlin DSL, alongside the removal of legacy Android-specific configurations, deprecated middleware components, and obsolete test suites.

8 changes.

This period focused on introducing the Cache5 API with multi-cache support and a new actor-based Multicaster architecture to improve concurrency and synchronization. It also expanded the library's ecosystem by adding RxJava 2 integration and experimental paging APIs for flexible data fetching, while stabilizing the build infrastructure with new Gradle convention plugins.

This change introduces a new \rx2\ module that provides RxJava 2 adapters for the Store library, enabling users to interact with the store using RxJava types. It adds factory functions to create \Fetcher\ and \SourceOfTruth\ implementations from RxJava \Single\, \Flowable\, and \Maybe\ sources, and provides extension functions on \Store\ to observe data streams as \Flowable\ or retrieve single values as \Single\. Additionally, it includes a builder extension to configure the store's sharing scheduler using an RxJava \Scheduler\.

rx2/src · high confidence

The core module introduces a new set of experimental APIs for managing data fetching and storage keys. Users can now define \StoreKey\ types for single items, as well as paginated (\Page\) and cursor-based (\Cursor\) collections, supporting sorting and filtering. The \StoreData\ interface distinguishes between single items and collections, with collections supporting item insertion strategies (Append, Prepend, Replace). A \KeyProvider\ interface allows conversion between single and collection keys. These APIs are marked with \@ExperimentalStoreApi\, indicating they are unstable and subject to change.

core · high confidence

The \cache/src/commonMain\ module now provides the Cache5 interface and implementation, introducing a builder-based API (\CacheBuilder\) that supports concurrency levels, maximum size/weight, and expiration policies (access and write). A key addition is \StoreMultiCache\, which manages two underlying caches to handle both individual items (\StoreKey.Single\) and collections (\StoreKey.Collection\) in a unified way, automatically keeping collection caches in sync when single items are updated or added.

cache/src/commonMain · high confidence

The cache/api module now exposes the Cache5 interface, defining core caching operations such as get, put, invalidate, and size. This update introduces CacheBuilder for configuring cache properties like maximum size and expiration policies, and adds StoreMultiCache and StoreMultiCacheAccessor to support layered caching strategies for both single and collection-based store keys.

cache/api · high confidence

The library now exposes a dedicated set of Kotlin extension functions for RxJava integration, allowing users to interact with the core data store using reactive streams. Specifically, \RxFetcherKt\ provides factory methods to create \Fetcher\ instances that return \Flowable\ or \Single\ types, while \RxSourceOfTruthKt\ offers similar builders for \SourceOfTruth\ components. The \RxStoreBuilderKt\ class adds a \withScheduler\ method to configure the execution context for store operations, and \RxStoreKt\ introduces convenience functions like \getSingle\, \freshSingle\, \observe\, \observeClear\, and \observeClearAll\ to perform reads and mutations on \Store\ instances using RxJava primitives.

rx2/api · high confidence

The repository has been initialized with the source and configuration for Store version 5.1.0-beta01. This release includes bug fixes for MutableStore synchronization, write-queue data races, and multicaster races, as well as improvements such as WasmJS targeting support and the removal of the kotlinx-datetime dependency. The project is now licensed under Apache 2.0 with copyright attribution to the Mobile Native Foundation, Dropbox, and The New York Times Company, and includes standard contributor guidelines, a code of conduct, and CI configuration for code coverage.

(repo-wide) · high confidence

The middleware module has removed several legacy classes that handled JSON parsing and file system operations, specifically deleting GsonReaderParser, GsonSourceParser, GsonStringParser, SourceFileReader, SourceFileWriter, SourcePersister, and the FileSystem abstraction along with its implementation. These components, which previously facilitated reading and writing data using RxJava 1 Observables and Okio BufferedSources, are no longer part of the codebase, indicating a shift away from this specific storage middleware implementation.

middleware/src/main/java · high confidence

The empty StoreActivity class in the sample application has been removed, as it contained no implementation logic beyond the standard Activity lifecycle call.

app/src/main/java · high confidence

The project's Gradle wrapper has been updated from version 2.14.1 to 9.6.1, introducing modern build features and improved distribution validation. Additionally, a new \gradle-daemon-jvm.properties\ file has been added to configure the Gradle daemon to use Azul JDK 17 across supported operating systems, ensuring consistent Java toolchain usage for the build process.

gradle · high confidence

The store module introduces the Store 5 API, adding a new MutableStore interface for local writes with conflict resolution and a Bookkeeper to track sync failures. The Fetcher API now supports fallback mechanisms and custom error types via FetcherResult, while the StoreBuilder exposes a converter for network-to-local transformations. Memory caching is now configurable via a MemoryPolicy builder, and the API surface is stabilized for Android, iOS, JVM, JS, and Wasm JS.

store · high confidence

The multicast module has been updated to version 5, introducing a new \Multicaster\ class and an internal \ChannelManager\ that uses a dedicated actor to manage upstream subscriptions and downstream dispatching. This architectural change replaces the previous implementation with a model where the upstream is suspended until at least one downstream acknowledges a value, ensuring synchronized delivery. The update includes a specific fix for a race condition where a new downstream subscriber could be left without a producer if added while an upstream cancellation was in flight, ensuring that downstreams are correctly restarted in such scenarios. Additionally, the module now includes a JVM binary compatibility API file and a ktlint baseline, indicating a stabilized public interface for the new version.

multicast · high confidence

The project introduces a new \tooling/plugins\ module containing convention plugins that standardize build configurations for Android, Kotlin Multiplatform, and code formatting. These plugins enforce a Java 11 compatibility target, configure Kotlin Multiplatform targets (including Wasm JS), and apply consistent linting and Spotless/KtLint rules. Additionally, a new \PublicationVersionChecks\ plugin and its corresponding tests ensure that generated Maven POMs and module metadata strictly match the version catalog, preventing stale or incorrect dependency versions in published artifacts.

tooling/plugins/src · high confidence

The app module no longer includes the .gitignore and proguard-rules.pro files, indicating a shift away from the previous Android-specific build setup. This change aligns with the project's move to target multiple platforms (Android, iOS, JVM, JS), as the removal of these files suggests that build configuration is now managed differently, likely through a shared or multi-platform build system rather than native Android-specific rules.

app · medium confidence

Added unit tests for Cache operations; Removed obsolete Android instrumentation test; Removed obsolete test suite for legacy store and file system implementations; Removed unused unit test file.

The build system has been modernized by migrating from legacy Groovy scripts and centralized dependency files to Gradle Version Catalogs (libs.versions.toml) and Kotlin DSL. This change introduces a new tooling module for convention plugins, updates the Android Gradle Plugin to 9.3.0 and Kotlin to 2.3.21, and restructures the project into multiplatform modules (store, cache, multicast, core, rx2). The legacy Android sample app and old build configurations have been removed, and the project now targets Android API 24+ with a minimum JVM compatibility of 11.

(dependencies) · high confidence

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

• CAI 63 → 64 (+0.9)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 96 → 96 (+0.0)
• Architecture 100 → 100 (+0.0)
• Maturity 59 → 59 (+0.1)
• Readiness 70 → 70 (+0.0)
• Security 54 → 54 (+0.0)
• Performance 100 (new)

• Hotspot: store/src/commonMain/kotlin/org/mobilenativefoundation/store/store5/impl/RealStore.kt (store/src/commonMain/kotlin/org/mobilenativefoundation/store/store5/impl/RealStore.kt)
• Off-boarding risk: anonymized user #1

• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview (README.md)
• Off-boarding risk: anonymized user #1

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

MobileNativeFoundation/Store 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.