In-memory OLTP for .NET
Build faster systems, faster


Build faster systems, faster

Build high quality, mission critical applications with real-time performance at a fraction of the time and cost. Memstate is a new

Moving data back and forth between disk and RAM is not just extremely inefficient, it requires multiple layers of complex software that can be eliminated entirely. Use Memstate to structure and manage your data in-memory, obtain transparent persistence, concurrency control and transactions with strong ACID guarantees. note: this is too techy... Make your applications 100x faster, and your developers 10x more productive. Memstate has many possible use cases but is designed primarily to handle complex OLTP workloads in a typical enterprise application.

100x performance

In-memory operations are orders of magnitude faster than disk operations. A single Memstate engine can execute millions of read transactions and tens of thousands of write transactions per second, all at submillisecond latency.

10x developer productivity

This is the #1 reason we built Memstate. The traditional backend architecture has so many complex parts and layers that can be eliminated when using an in-memory centric architecture. The traditional RDBMS backend developer needs to deal with data access, relational modeling, object-relational mapping, data type conversion, sql tuning, caching, migrations and transaction management to name a few things. With Memstate, a single in-memory domain model replaces the domain layer, data access and data layers.

Software quality

Memstate transactions are 100% ACID out of the box. Commands execute one at a time, transitioning the in-memory model from one consistent state to the next. The data model, commands and queries are all strongly typed, compile-time checked, version controlled with the rest of your code and easily unit tested.

Bring your own data model

Memstate in-memory data models, commands and queries are written in C#. Create your own domain specific model, or use one of the built-ins:

  • Relational
  • Document
  • Key/value
  • Graph
  • Xml
  • Redis clone
  • Message Broker


sub-millisecond latency

Modular architecture

Memstate can easily be customized to meet your specific requirements. Choose from existing modules or implement custom plugins. Storage and wire formats:

  • JSON
  • Wire (binary)
  • Protobuf (planned)
Backing stores:
  • Event Store
  • PostgreSQL
  • Local filesystem

Time travel

The command journal contains a complete history of every change ever made to the data. This means that:

  • Data can be restored to to any point in time
  • You know exactly who did what and when
  • Software engineers can go back in time and se

Not just .NET

The HTTP Command/Query API lets any client that can speak HTTP execute commands and queries.

Simple management

Easily administer Memstate Server using a simple and intuitive web-based interface.

  • Monitor, start and stop nodes
  • Manage replication
  • Execute ad-hoc queries

Open Source and free

Memstate is fully open source and licensed under the LGPL license. The source code is hosted on Github. Memstate is free to use for both commercial and non-commercial purposes.

Runs on Linux, MacOS and Windows

Memstate is based on .NET Standard 2.0 and runs on .NET Core >=2.0, .NET Framework >=4.6.1 or Mono >=5.4.

High availability

Memstate supports any number of read/write replicas, just connect to

How does it work?

When the memstate engine starts, the in-memory model is restored by replaying all of the commands in the command journal. When the model is ready the engine starts processing commands and queries. Commands are sent to the underlying storage provider

So what's the catch?

Here are the major drawbacks:

  • The command journal, unless truncated, can become large over time
  • Truncating the journal erases the history of events
  • Snapshots take time to read and write
  • System is readonly while snapshot is being taken
  • Bringing a large system online can take time