Skip to content

KurrentDB vs Chronicle: event stores compared

KurrentDB and Cratis Chronicle both store events in a separate server. Choose between them by how you want to build read models (views derived from events), connect consumers and operate storage: KurrentDB has its own storage engine; Chronicle uses a storage database you choose and manages event processing alongside the log.

The Cratis team wrote this page, and Chronicle is a Cratis product. KurrentDB was formerly called EventStoreDB. The comparison below covers named versions, with sources beside the capabilities that affect the choice. For a three-way comparison that includes Marten, see Event sourcing in .NET, and for the JVM see Event sourcing on the JVM. All our comparisons follow the method in How Cratis writes comparisons.

Choose KurrentDB when you want a dedicated event database and plan to build application read models through consumers or connectors. Its documented connectors and Kurrent Cloud service matter if you want ready-made destinations or do not want to operate the database yourself.

Choose Chronicle when you want the server to manage read-model building as well as the event log. A projection maps events into a read model inside the kernel; a reducer computes state in your application while the server tracks progress. Check the APIs in your chosen client before designing around either approach.

Storage choice can settle the decision. Chronicle supports MongoDB, PostgreSQL, SQL Server and SQLite, but the compared version requires MongoDB for multiple nodes. The storage and clustering sections below explain that boundary.

Product Version compared Version source
KurrentDB 26.2.3, covered by the v26.2 server docs KurrentDB release v26.2.3
Cratis Chronicle 19.92.2 Chronicle release v19.92.2

KurrentDB 26.2 is a short-term-support release; 26.0 is the long-term-support line (release schedule). Licensing differs between the two, as described below.

Both products run as a server that your applications call over the network. Neither runs inside your application process.

KurrentDB is a database that stores events in streams in its own storage engine. Clients talk to it over gRPC, and it also has an HTTP interface (introduction). It runs as a single node or as a cluster of three nodes (installation).

Chronicle runs as the Chronicle Kernel, built on Microsoft Orleans. Clients call it over gRPC, a remote procedure call protocol, and it also exposes HTTP surfaces (architecture). It stores events in a database you choose and manages the observers that process them. Projections run in the kernel; reducer and reactor handlers run in your connected application, with the server tracking each observer’s position.

That changes the work around a new view. With KurrentDB, decide where a consumer writes the view and how it resumes processing. With Chronicle, choose a projection or reducer and the sink where Chronicle writes the result. A sink is the destination database for a read model. Both designs still require you to model the events and handle failures in application side effects.

Question KurrentDB 26.2.3 Chronicle 19.92.2
Product boundary Dedicated event-store database server (introduction) Event-sourcing server plus client SDKs (architecture)
Event storage Streams in KurrentDB’s own storage engine (event streams) MongoDB (default), PostgreSQL, SQL Server, SQLite, in-memory (storage)
Clients Python, Node.js, Java, .NET, Go and Rust listed as supported; Ruby and Elixir as community clients (introduction) The snapshot covers .NET, TypeScript, Kotlin/Java and Elixir. Check current package availability and limits on the clients page.
Server-side subscriptions Catch-up subscriptions keep their position in the client; persistent subscriptions keep it on the server, with consumer groups and at-least-once delivery (persistent subscriptions) Observers keep their offset on the server as a sequence number (event sequence, observers)
Server-side projections JavaScript projections on the server (projections); a second engine is also documented (engine V2) Projections that run in the kernel (model-bound, declarative, fluent) and reducers whose handlers run in your application, both building read models (choosing a style)
Read-model storage Not part of KurrentDB; projections emit events, and KurrentDB suggests a separate read model fed by a catch-up subscription for many workloads (projections) Sinks write read models to MongoDB or SQL (sinks)
Concurrency control Expected stream state on append (.NET client); multi-stream appends with an expected version per stream (what’s new) Concurrency scopes over event-source and event-type tags, plus constraints (concurrency, DCB)
Export to other systems Server-side connectors with sinks including HTTP, Kafka, RabbitMQ, MongoDB, Elasticsearch, Pulsar, SQL and Serilog (connectors) Reactors run your own code in your application, driven by the server (reactors); no connector catalog documented
Multi-tenancy Not publicly documented Namespaces inside an event store (namespaces)
Event versioning Not publicly documented Generations that translate old events (event evolution)
Personal data Redaction tool that blanks the data of chosen events, run on each node (redaction) Encryption of [PII] properties with a key per subject, erased by deleting the key, plus event redaction (compliance)
Managed service Kurrent Cloud on AWS, Azure and GCP (installation) Not publicly documented
Clustering and operations Single node or cluster; Prometheus metrics and OTLP export (installation, metrics) In 19.92.2, multi-node needs MongoDB storage; check current clustering guidance for later versions. Inspection through Workbench, CLI, telemetry.
License Kurrent License v1, not OSI-approved; see below (LICENSE) MIT (LICENSE)

KurrentDB is licensed under Kurrent License v1 (KLv1). Its documentation says the source code is available to view and that KLv1 is not an open-source license approved by the Open Source Initiative (OSI) (introduction). The license text says you may not provide the software to third parties as a hosted or managed service that gives users access to a substantial set of its features (LICENSE).

The terms changed in 26.2. From that release, single-node deployments have access to all licensed features without a key, and multi-node deployments need a valid license key on every node (what’s new in 26.2). In 26.0, enterprise features were enabled only with a license key (26.0 introduction). If you plan to run a cluster, read the current terms first.

Chronicle is MIT licensed.

KurrentDB gives you three ways to react to events. Catch-up subscriptions are driven by the client, which stores its own position. Persistent subscriptions keep the position on the server and let several consumers in a group share the load, with at-least-once delivery. Its docs warn that events in a consumer group can arrive out of order (persistent subscriptions). Connectors run on the server and send events to external systems through sinks (Understanding Connectors).

KurrentDB projections are JavaScript that reads events and appends or links new events. Its own docs point out that many problems fit better as a read model in another database populated by a catch-up subscription (projections).

Chronicle maintains a read model from a projection or reducer and writes it to MongoDB or SQL. Materialized read models are eventually consistent: a successful append does not mean the view has caught up. A passive model is computed on read instead, but freshness alone does not protect a command’s decision from a concurrent append (projections). Reactors run application side effects; your application remains responsible for making those effects safe to repeat (observers).

KurrentDB documents archiving of older data to cheaper blob storage, backup and scavenging to reclaim space.

Chronicle stores events in a database you choose and ships as the cratis/chronicle Docker image, with production hosting and clustering covered in its docs. Choosing Chronicle means running the server in addition to its database. In 19.92.2, multi-node clustering requires MongoDB; PostgreSQL, SQL Server and SQLite support one node. Later versions have different clustering options, so use the hosting documentation for the version you intend to deploy.

KurrentDB’s introduction lists gRPC clients for Python, Node.js (JavaScript and TypeScript), Java, .NET, Go and Rust, and community clients for Ruby and Elixir (introduction).

Chronicle has a .NET SDK, and released clients for TypeScript (@cratis/chronicle), Kotlin and Java (io.cratis:chronicle) and Elixir (cratis_chronicle). See Chronicle in your language for package availability, including languages outside this snapshot. A client release has its own API surface and version constraints; it does not establish parity with .NET. Check where the clients differ before depending on a particular operation.

KurrentDB documents that events are immutable. To remove data, it recommends rewriting the stream to a new stream without the data, deleting the old stream and running a scavenge. If that is impractical, a redaction tool blanks the data of specific events. The docs call it a last resort that may affect subscriptions and projections, and say the tool is available on request (redaction).

Chronicle marks personal data with PII attributes, encrypts those values at rest with a key per subject, and erases a subject by revoking the key. Whole events can be redacted while the sequence and audit metadata remain. See Chronicle compliance and Auth and compliance.

The design decision comes before the erasure request. Chronicle can erase access to values that were marked and encrypted when appended; key deletion does not reach plaintext copies held elsewhere. KurrentDB’s documented approaches rewrite or blank stored events, or move data to a new stream. Neither mechanism alone establishes that your application meets its regulatory obligations.

KurrentDB fits when you want to keep the event database separate from your application framework and choose how consumers build views. Its official Python, Go and Rust clients may also settle a language requirement. Compare the operations you need with Chronicle’s client coverage, rather than treating a language name as a parity claim.

If you do not want to operate the database, evaluate Kurrent Cloud. If you do operate it, its documented archiving and backup workflows may fit your storage policy. No managed Chronicle service is documented in this snapshot.

Ready-made connectors are another reason to choose KurrentDB. Sending events to Kafka, RabbitMQ or Elasticsearch through a server-side connector is a different responsibility from writing and hosting a Chronicle reactor yourself.

Moving between the two is not a configuration change. They use different storage, different consumer and projection models, and different client APIs, so a migration touches application code and not only data.

The reviewed sources did not provide a migration guide in either direction. Plan for application changes, including how stream names map to event sources and how subscriptions become observers. If you want help planning a move, ask the community.

  1. Do you want a dedicated event database, or a server that also runs your projections and manages your reducers and reactors?
  2. Which languages must read and write the history, and do their clients expose the operations you need?
  3. Do you need ready-made connectors to external systems, or a managed service?
  4. Will you run a cluster, and are the KLv1 terms for it acceptable?
  5. How must personal data in events be protected and erased?
  • This is a documentation comparison, not a benchmark or a production evaluation.
  • We reviewed the pages linked here. KurrentDB may document more than we found, and its docs change independently of ours.
  • KurrentDB 26.0 long-term support (LTS) and 26.2 short-term support (STS) differ in licensing and features; this snapshot compares 26.2.3.
  • Client availability does not establish parity between clients.

Checked 2026-10-19:

We recheck this page when either product ships a relevant major or minor release or changes its license, and at least every 90 days. If a statement cannot be confirmed from a product’s own current public sources, we correct or remove it.

If you find an error or a better first-party source, send the correction.