What are the main features of mrousavy/react-native-mmkv?

The main features of mrousavy/react-native-mmkv are: Synchronous Native Execution, Application State Synchronization, Synchronous Implementations, Persistence Layers, Key-Value, Local Persistence Modules, Memory-Mapped I/O, Encrypted Device Persistence.

React Native Mmkv - fast encrypted mobile

Name: mrousavy/react-native-mmkv
Author: mrousavy

react-native-mmkv is a synchronous mobile persistence system that provides an encrypted key-value store for mobile applications. It serves as a high-performance wrapper for the MMKV storage engine, eliminating asynchronous overhead by reading and writing values directly to disk.

The project distinguishes itself through shared app group storage, which allows data access across multiple application extensions via a shared filesystem directory. It also provides state-synced storage hooks that automatically trigger component updates when stored key-value pairs change.

The system covers a broad range of mobile data management capabilities, including multi-instance storage isolation, data migration utilities, and storage health optimization. Security is handled through private-key encryption to protect persisted data and ensure storage file confidentiality.

Features

Synchronous Native Execution - Eliminates asynchronous promise latency by executing data retrieval and persistence through blocking C++ calls on the main thread.
Application State Synchronization - Syncs application state with local storage using hooks that trigger immediate UI updates when values change.
Synchronous Implementations - Provides a high-performance synchronous key-value store that eliminates the overhead of asynchronous calls.
Persistence Layers - Provides a synchronous persistence layer that reads and writes values directly to disk to eliminate asynchronous overhead.
Key-Value - Implements a high-performance key-value storage engine based on MMKV for mobile applications.
Local Persistence Modules - Serves as a high-performance local storage solution specifically designed for the React Native ecosystem.
Memory-Mapped I/O - Uses memory-mapped file I/O to enable near-instantaneous read and write operations by mapping files directly into virtual address space.
Encrypted Device Persistence - Protects sensitive key-value data on mobile devices using private-key encryption to prevent unauthorized file access.
Encrypted Key-Value Stores - Provides a secure key-value storage solution that protects persisted data using private key encryption.
Symmetric Encryption - Employs symmetric encryption to protect persisted data before it is written to the disk.
Persistence Sync Hooks - Offers state-synced storage hooks that automatically trigger component updates when stored key-value pairs change.
Reactive State Syncing - Implements a callback mechanism that notifies JavaScript subscribers of native data changes to trigger reactive UI updates.
React State Bindings - Ships state-synced storage hooks that automatically trigger React component updates when stored values change.
Cross-Target Data Sharing - Enables data access across a main application and its extensions by using a shared filesystem directory.
Per-Instance Data Isolation - Isolates data sets into separate containers using unique identifiers to decouple global settings from user-specific data.
User Data Management - Manages isolated storage containers to organize global settings and user-specific information on mobile devices.
Shared App Instances - Allows a main application and its extensions to read and write the same data via a shared app group directory.
JavaScript Native Interfaces - Provides direct C++ JSI bindings to eliminate serialization overhead between JavaScript and the native storage engine.
Storage Encryption - Provides private-key encryption for key-value pairs to ensure the confidentiality of the underlying storage files.
App Group Directories - Points the storage engine to a shared filesystem directory to enable data access across multiple application extensions.

ammarahm-ed/react-native-mmkv-storage

1,752View on GitHub

This project provides a high-performance key-value storage solution for mobile applications, utilizing memory-mapped files to enable rapid read and write operations. It functions as a persistent data layer that integrates directly with the JavaScript runtime to minimize overhead, while supporting reactive state synchronization to ensure interface components update automatically when stored data changes. The storage system distinguishes itself through its ability to manage multiple independent database instances, which organizes data by module and prevents collisions between application compon

isar/hive

4,391View on GitHub

Hive is a lightweight NoSQL key-value database written in pure Dart for local data persistence. It functions as a type-safe document store that allows for the saving and retrieval of complex data structures and custom objects. The system distinguishes itself through the use of custom adapters for object serialization and symmetric-key encryption to secure data at rest. For web environments, it provides a persistence layer that wraps IndexedDB and utilizes web workers. The project covers broad capability areas including container management, atomic transactional writes, and indexed data retri

How this analysis was created: This summary and feature list are AI-generated from collected project material and can contain mistakes. Stars, license and language are imported from GitHub. Inclusion does not mean that we have tested or audited this project. Check the source documentation for any feature you depend on. Learn more on our About page.

NutsDB is an ACID-compliant, embedded transactional storage engine that functions as both a disk-backed key-value store and an in-memory data structure store. It provides atomic and serializable transactions with commit and rollback capabilities to ensure strict data consistency for applications requiring a lightweight persistence layer. The engine distinguishes itself by supporting a variety of complex data types, including lists, sets, and sorted sets, alongside standard byte-slice storage. It implements a transactional storage model featuring hot backups and a compaction algorithm to maint

reflux/refluxjs

5,323View on GitHub

Refluxjs is a state management library designed to implement a unidirectional dataflow architecture. It manages application state through a strict cycle of actions and stores to prevent unpredictable update loops. The library coordinates asynchronous operations by managing event streams and triggering related success or failure actions. It also provides a global state registry that tracks store states via unique identifiers, enabling deep cloning for persistence and time-travel debugging. Its capability surface covers centralized state management, including the creation of data stores and de

mrousavyreact-native-mmkv