Ultra-High Performance

Java Object-Graph Persistence

For Java Cloud-Native Microservice & Classic Enterprise Applications

Realize ultra-fast in-memory data processing with pure Java.
Microsecond query time. Low-latency data access. Gigantic data throughput and workloads.
Save lots of CPU power, CO2 emission, and costs in the data center.

Traditional Java Persistence

Complex. Expensive Latencies. Higher Infrastructure costs.

In Java, everything is an object. In contrast, all databases come with their own specific data structure that is incompatible with Java objects (impedance mismatch). As a consequence, a mapping is required, which means all data must be converted behind the scenes. Conversions are inefficient, lead to enormous loss of performance and latencies, and are linked to further serious disadvantages.

Data Conversion

Through Every Single Read & Write!

  • Conversions take up to 90% of query time in total
  • Drastic performance loss
  • Expensive latencies
  • Burns lots of CPU power
  • Increases your infrastructure costs
  • Two different data models required
  • Complex framework or other mappings required
  • Additional caching framework required
  • High complexity, development effort & costs

MicroStream Persistence

MicroStream is joyfully easy to use Java API you can download via Maven.

MicroStream is a Java-native object graph persistence engine for storing any complex Java object graph or any single subgraph and restoring it in RAM at any time by using a fundamentally new serialization concept designed from scratch. With MicroStream, not only the entire object graph, but also partial subgraphs, or only single objects can be restored in RAM on demand. Beyond serialization, MicroStream is ACID transaction safe, can handle your class changes, provides a garbage collector for the storage, multi-threaded IO, and connectors for various data storages.

No Mappings at all!

Conversion Eliminated

  • Incredible performance boost
  • Eliminates expensive latencies
  • Saves lots of CPU power
  • Reduces your infrastructure costs
  • Simple architecture
  • Reduces the development effort and costs
  • Pure Java, developer's joy


Features MicroStream is joyfully easy to use Java API you can download via Maven.

Tiny Java Library

MicroStream is a tiny Java library without any dependencies wihch you can download via Maven. It runs within your app's JVM process.

Data Model: Java Classes Only

Only 1 data model: Java classes. No more specific database model. No expensive mappings or data conversion. Design your model freely.

Multi-Model Data Structure

A Java object graph is by nature a multi-model data structure. You can add any object, lists and other collections, key-value pairs as well as any document.

No Annoying Restrictions

No need for special superclasses, interfaces such as Serializable, annotations or any other internal configurations. Just use POJOs.

Store Any Java Type

Any meaningful Java types can be persisted. Storing any types from 3rd party APIs is trouble-free.

Dynamic Store Ops

Store any single object, any subgraph, or the complete object graph by calling only one store method. In any case, only the delta will be stored.

ACID Transaction-Safty

Any meaningful Java types can be persisted. Storing any types from 3rd party APIs is trouble-free.

Append-Only Log

Each store operation adds the objects appended to your storage by using a binary data format for best performance.


Each store is an atomic operation, ACID transaction-safe, and strong consistent.

No Object Copies

Loaded objects are fully automated merged into your object graph. You don't have to deal with inconvenient object copies and persistent contexts.

Queries: Java Streams API

The Java Streams API enables you to search even huge and complex object graphs in memory in microsecond query time.

No Classic Selects, Just Getter

Loaded objects are fully automated merged into your object graph. You don't have to deal with inconvenient object copies and persistent contexts.

Memory Management

With MicroStream, RAM is still fully managed by the JVM, but you can remove lazy-loaded references at any time to free up RAM.

Multithreaded IO Ops

By using channels, IO operations will be executed multithreaded which increases the performance of your application.

Class Change Handling

Different versions of your classes are handled automatically through the runtime. No refactorings required.

Storage Garbage Collector

Legacy and corrupt objects in the storage are removed by the MicroStream garbage collector automatically through the runtime.

REST Interface

MicroStream provides you a REST API that enables remote access to your persistent storage data.

Storage Viewer

MicroStream comes with a web interface that allows you to browse through your persistent storage data.


Reliable and fully individual configurable data backup processes. Alternatively, you can use the backup function of your database.

Simple Migration

Both, migrating the data to or away from MicroStream is simple by using   CSV import/export.

Runs Wherever Java Runs

MicroStream runs on desktops, on the server, in containers, in the cloud, on mobile & edge devices, as a native image & is perfect for microservices.

Use Powerful Features From the Java Ecosystem

Accessing Your Data

Expose your data to external applications or services to enable accessing your data. Learn more

Manage Terabyte RAM Sizes

Azul's JVM Platform Prime minimizes garbage collection pause time and enables your Java app to handle up to 20 Terabyte RAM size trouble-free. Learn more

Fulltext Search

Apache Lucene is a powerful search engine for Java. Lucene allows you to add such as full-text search to your MicroStream app. Learn more

Java In-Memory Data Processing Approach

Turn Java Into a High- Performance In-Memory Data Processing Reactor.

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 be basically anything, a plain object, but also a collection, document, or binary. All Java types are supported. You can design your object graph freely. You can add millions of nodes, build subgraphs and connect objects with circle references. It's by nature a multi- model data structure for storing structured data but allows you also handling unstructured data by using collections. Searching object graphs in RAM is super-fast and takes mostly only microseconds.

  • Predestined for building in-memory databases
  • Fully indexed out-of-the-box
  • Scale from one object to millions of objects and subgraphs
  • Incridible in-memory performance: Microsecond query time
  • Eliminate bottlenecks and expensive latencies
  • Java Object graph: the perfect data structure for any use-case
  • Handle any complexity trouble-free
  • Handling terabyte database size in-memory is possible
  • Fully automatic memory management by the JVM
  • JDK concepts only
  • Real multi-model data structure - any Java type can be used
  • Using circle references is possible
  • Query object graphs with Java Streams API or GraphQL
  • Tremendous throughput and workloads

Some Code

MicroStream is joyfully easy to use Java API you can download via Maven.

Data Model: Just POJOs

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 effortfully to a specific 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. You can use just POJOs.

public class Customer {

   private String firstname;
   private String lastname;
   private String email;
   private LocalDate dateOfBirth;
   private Boolean active;
   private Set<Order> orders;     

Data model:
Java classes only

No dependencies,
just use POJOs

No need for special superclasses, interfaces or annotations

Use existing classes as they are, no strings attached

Any Java types
are supported

Use any types from 3rd party APIs

Design your object model freely without any limitations

Using inheritance
is trouble-free

Migrating to MicroStream is trouble-free

Persisting Objects

MicroStream enables you to store any Java type. To persist data, you only have to call one store method. It's your decision, if and when an object or subgraph should be persisted. The data are stored as binary data appended to the file storage. Every store is an atomic operation that is transaction-safe.

DataRoot root = microstreamDemo.root();

Store any single object or subgraph explicitly

Store any Java type, any suited type is supported

Using inheritance is trouble-free

Binary data format, no expensive mappings

Atomic operation and ACID transaction-safe

Strong consistency

Append-only log strategy

Multithreaded write ops for max performance

Gigantic data throughput

Custom-tailored type handling for best performance

Replaces 3 CRUD ops: Create, Update & Delete

public class Customer {
  private Lazy<Set<Order>> orders;
  public Set<Order> getOrders() {
     return Lazy.get(this.orders);
  public void setOrders(final Set<Order> orders) {
     this.orders = Lazy.Reference(orders);

Loading Objects Dynamically Into RAM

 If you have enough RAM, you can load your entire database into RAM to get max speed without the need for any I/O ops. However, if your RAM capacity is limited, you can use lazy-loading to load data on- demand only, such as bigger collections, BLOBs, documents etc. To reduce RAM usage and garbage collection pause time, lazy references can be removed from RAM at any time. Loaded objects are merged into the object graph fully automatic, thus you don't have to deal with inconvenient object copies.

Sufficient RAM available: Restore the entire object-graph

RAM limited: Load single objects or subgraphs on-demand

Loaded objects are merged into the object graph automatically

No inconvenient object copies

No more classic selects, simply call getter

Minimizing expensive IO ops

Multithreaded read ops for max performance

Gigantic data throughput

public static void booksByAuthor()
      final Map<Author, List<Book>> booksByAuthor =
            .collect(groupingBy(book -> book.author()));
       booksByAuthor.entrySet().forEach(e -> {
           e.getValue().forEach(book -> {


Microsecond Query-Time
with Java Streams API

Instead of querying a remote database server, just search your object graph in memory by using Java Streams. The Streams API is an enormously powerful and fully typesafe Java API for searching object graphs highly efficiently. Searching even giant and complex object graphs by iterating hundreds of nodes takes only microseconds.

Core Java instead of database query languages

Queries are executed in- memory

Simultaneously query execution with Parallel Streams

No network bottlenecks, no latency.

Type-safe, clean and great testable code

Minimizing expensive IO ops

Supported Storages

Further Connectors are in Progress

Cloud Object Store

Use any JVM Technology

MicroStream is a small Java library that can be used with all JVM languages.

Runs Wherever Java Runs

One and the Same Java API for All Platforms.



Any Cloud


Native Image



JDK 8+


Warp Speed

In comparison to the traditional DB server queries, pure Java in-memory ops are executed in microseconds - up to an unbelievable 1000x faster. This eliminates your performance issues and lets you build fascinating new innovations, features, and products.

Save up to 92% CPU Power

The incredible performance of pure Java in- memory data processing maximizes data throughput and workloads and minimizes the required CPU power for your server-side apps and microservices and saves up to 92% of your data center costs.

Developer Joy

Developers love the pure Java data processing approach, the fully OO- programming model, the high-quality API and simple architecture. Boost your entire database development process and reduce your time to market.

Get Started

MicroStream is joyfully easy to use Java API you can download via Maven.

Personal Online-Call

You are a decision-maker and wondering how MicroStream works, whether your organization can benefit from MicroStream, if MicroStream will meet your requirements and how our process works?

Book a Call

Company Training

Experimenting takes you valuable time and money, is a potential source of conceptual errors and you have to find out best practices for your own. We provide you individual company training tailored for your team.

Ask for a Quote


We support you from building a proof-of-concept, through building the architecture and the object model up to implementing your entire application or single parts of it and run it in production in the data center.

Ask for a Quote