High-Performance Micro Persistence for Android

Store Java Object Graphs Natively. Turns SQLite Into Ultra-High-Performance Mobile Database. Microsecond Response Time. Ultra-High Throughput. Minimum of Latencies. Create Ultra-fast In-Memory Database Apps on Top of SQLite with Pure Java and Kotlin.

Get Started

Why MicroStream?

MicroStream is the very first data storage technology that streams real Java object graphs directly on disk and loads any object or subgraph back in RAM dynamically when accessed. No more external database system. No more database data structure. No more mappings. No more data conversion. No waste of computing time. In-Memory database. Ultra- fast. Pure Java only. Game-changer concept that provides you fantastic benefits.

Ultra-fast

In-Memory queries executed in microseconds. X-times faster than any external mobile database system. Super small footprint. Multithreaded. No magic, but simply core Java concepts and unleashed pure Android Runtime power.

Specially Built for Java

No more external mobile database system. Java classes only. No more mappings. No more query language. Pure Java concepts only. Eliminates boilerplate code. High- quality Java API. From Java developers especially for Java developers. Feels like an Android-native function.

Simplest Data Storage Ever

The simplest data storage ever. Build and deploy database apps decisively faster. Increase your productivity. Reduce your time to market. Simplify and accelerate your entire development process as well as maintenance.

How does it Work?

Java Object Graph -
Perfect Multi Model
Data Structure

Java Object Graphs are predestined to be used as In-Memory database on Android devices.

Java provides the perfect data structure that is suited and used for every use-case. With an object graph, you can build up a highly complex data structure but allows you to store simple lists as well. Any node can basically be anything, a plain object, but also a collection, document, or binary. All Java types are supported. You can design your any object graph and any single object freely. You can have millions of nodes and subgraphs as well as only one single node. It is by nature a multi-model data structure for storing structured data but allows also handling unstructured data by using collections. Searching object graphs in RAM is super-fast and takes mostly only microseconds.

Only One Data Model: Java Classes Only!

Independent from Database Data Models. No more Mappings.
Let your Classes as they are. No Strings attached!

Your Java classes are your only data model. There is no more additional database data model. Thus, you don't have to adapt your classes effortful to a special database data model. You can design your object model freely and use any Java type. There is no need for special superclasses, special interfaces, annotations, mappings, or any other internal configurations. No dependencies. Just POJOs. You can use your classes as they are. If you have to change your data model, simply change your classes. That's all.

Storing Data persistently on the Device

MicroStream enables you to persist single Objects and complex Subgraphs.

You can store everything from a single object up to complex subgraphs persistently ondisk of the mobile device by calling only one simple store method. You decide explicitly if and when an object is persisted. All stored objects are appended to the file-storage. Any store operation is automatically transaction-safe. MicroStream enables you to store any Java type, collections, any custom type, and even objects from third-party APIs.

Store any single Object or Subgraph explicitly
Store any Android Type
Custom-tailored Type Handling for best Performance
Using Inheritance is Trouble-free
ACID Transactions even through Power Failures or System Crashes
Multithreaded super-fast Write Operations
Strong Consistency
High Secure
Covers 3 CRUD Operations: Create, Update & Delete

Loading Data

MicroStream allows you to load single Objects and complex Subgraphs. No more classic Selects. Just calling Getter.

After starting your app, MicroStream initially loads all object IDs only and creates the entire object graph structure in RAM. Thus, you get a fully indexed in-memory database.

Loading Data is fully automized

Loading data is different from database systems. MicroStream is fully object-oriented. There are no more classic selects. To read an object, you just have to call its get method as you are used to, and MicroStream takes care of the rest.

Fully In-Memory is best, but not mandatory

You decide, how much data you load into RAM. If you have enough RAM, you can load the entire database into RAM and benefit from max speed without any IO ops. If your data storage is much bigger than your RAM, you can load data on-demand only. In order to do that, MicroStream enables you to load any single object as well as complex subgraphs lazy.

No Object Copies

Loaded objects are merged into the object graph automatically, so you never have to deal with inconvenient object copies.

Load any single Subgraph on Demand
Loaded Objects are automatically merged into the Object Graph
No inconvenient Object Copies
No more classic Selects, simply call Getter
Memory Management by MicroStream or explicit
Multithreaded super-fast Read Operations

Queries with Java Streams API Executed in Microseconds,
up to X-Times faster than any Mobile  Database System.

Java Streams API is an enormously powerful and fully typesafe query language for searching object graphs. Searching even giant and complex object- graphs in the memory takes only microseconds while database systems waste milliseconds for the same result. In other words, Java Streams are X- times faster than any mobile database system.

public static void booksByAuthor()
{
    final Map<Author, List<Book>> booksByAuthor =
        ReadMeCorp.data().books().stream()
        .collect(groupingBy(book -> book.author()));

    booksByAuthor.entrySet().forEach(e -> {
        System.out.println(e.getKey().name());
        e.getValue().forEach(book -> {
            System.out.print('\t');
            System.out.println(book.title());
        });
    });
}
Core Java instead of proprietary Query Languages
Queries are executed In-Memory
Parallel Execution of Queries possible
No Network Bottlenecks, no Latencies
Type-safe, good testable and clean Code

More Core Features

Storage Garbage Collector

Legacy and corrupt data are removed from the storage by MicroStream automatically.

Class Version Handling

Different versions of your classes are handled automatically. Custom mappings are also supported.

Backups

Reliable and fully individual configurable data backup processes.

REST Interface

REST interface allows remote access to the storage data.

Storage Browser

Graphical user interface for browsing through your storage data remotely.

Highly Configurable

MicroStream is highly configurable through its API.

High Quality API

MicroStream is a high-quality tiny Java API.

Simple Implementation

MicroStream can be included in any Java project via Maven.

Create ultra-fast in-memory database apps starting today!