Java In-Memory Database. Persisting plain Java objects. No more mapping needed,
no more query language, up to 1,000 times faster than any SQL database.
Develop impressive real-time business apps.
Do you have complex data structure, lots queries and time-consuming joins? Is your database already stretched to it's limit? Or are you just dreaming about a high-speed business application? is exactly what you need.

Develop impressive fast
Realtime Business Apps


Why ? is an Open Source Java database management system which enables you to persist plain Java objects. In order to do this, streams your Java objects exactly as they are existing in the memory to the file storage. is the only DBMS that dispenses completely with any object mapping. This means that does not convert your objects to be persisted to an artificial structure or format, such as relations, JSON, XML, etc. This alone accelerates database apps enormously.


Up to 1,000 times faster than SQL databases !

Furthermore, enables you to make the most of your memory by pre-loading large part of your data directly in the main memory. Thus, you can access and query your data in-memory in a elegant and powerful way by using Java 8 streams. As a consequence the average access time for your queries is only a few microseconds, which is up to 1,000 times faster than any SQL database. enables you to develop high-speed applications which will make your users happy and shocking your competitors. Because of that, is a manager's dream. is a developers dream as well. developers have to create and maintain just only one data model, nothing but a plain Java object model. You do not have to adjust your objects making them compatible with a different database structure. You not even have to care for entity object lifecycle as with JPA. This reduces the complexity radically, eliminates a huge potential error source completely, simplyfies and accelerates your entire database development process and reduces your costs for implementing and maintaining enormously.

Persisting Plain
Java Objects enables you to persist any Java object exactly like it is existing in the memory, without mapping to any other structure or format. streams the entire object graph or only parts of it directly to the file storage.
When you start your app, enables you to pre-load large part of your object graph directly into the memory by using lazy-loading. Therefore, data accesses with are enormously fast, which makes your application becomming a real-time solution.

No More Monolithic

Database Server.

Easy to embed, Simple To Deploy, no administration. Perfect for Embedded,
Cloud & Microservices. runs within your application layer as a light-weight part of your application. You only have include a 12 MB JAR file to use it. Thus, is predestinated for embedded, cloud and microservices usage.
electronics-1607250 (1)

In-Memory Power ensures automatically by using lazy-loading that all needed data are available in main memory. You can also take control at any time. You can pre-load part of your data or even the entire object graph in case enough memory is available. Queries are executed in memory in microseconds. Up to 1,000 times faster than SQL queries. With you are prepared best for smaller business apps as well as for big data.

No More
Query Language.

You can write all of your Queries with
Java 8 Streams.
With Jetstream one you don't have to learn another query language or API. ensures automatically that all needed data are available in main memory. This allows you to execute queries directly in memory in microseconds by using Java 8 streams.
List<Integer> transactionsIds =
               .filter(t -> t.getType() == Transaction.GROCERY)


Object-Relational Mapping


No More Mapping

Java objects and relational databases are incompatible. This problem is called obect- relational impedance mismatch and well known since more than 40 years.
JPA is trying to solve that problem by mapping Java objects to relational database tables. But OR- mapping is very expensive. It takes lots computing time and brakes your application. Caches are strongly needed to compensate the loss of time. Thus OR-mapping is basically a huge potential source of error and it increases the complexity for the developer tremendously.
What's about No-SQL? Mapping Java objects to other artificial formats like XML, JSON, key-value couples etc. is pretty much the same overhead and moreover it is needed not at all.

Developers' Dream

Developing and supporting only 1 data model - your Java object model. No JPA needed. No more query language to learn. Reduces the complexity of database development with Java tremendously.

For the very first time, the entire database application is just Java.
What is a Java developer working with preferably?
Database tables, JSON, XML, key-value stores? We as Java developers love objects, right?
Why do we destroy our objects just to persist them, if we actually do not have to?
Why don't we persist our objects just as they are, instead of making life unnecessarily difficult using artificial formats and sophisticated mappings? This is exactly what does.


Thomas Muenz
Chief Developer & Inventor of