Cloud Parts

KurrentDBRenamed

A database built for event sourcing, formerly EventStoreDB: it stores immutable events in streams on one append-only log and pushes them to subscribers.

What it is
Persistence: state, events and replay (event sourcing)
Type
Commercial product
Made by
Kurrent
License
Kurrent License v1 (source available, not OSI open source) since 25.0 in March 2025; Event Store License v2 for 24.10; a BSD 3-clause license for earlier versions
Status
Renamed. Called EventStoreDB until version 25.0 in March 2025.
Facts checked
8 October 2026
Website Source code

What it is

KurrentDB keeps every event in a single append-only log, in the order it was written. Each event also belongs to a stream, named by the application, usually one per entity, such as order-123. Reading a stream returns just that entity’s events, so the application can replay them to rebuild its state. Every append can name the version the writer expects the stream to be at (NO_STREAM, EXISTS or an exact number), and the write fails if another writer got there first: optimistic concurrency, per stream. Retrying an append with the same event IDs doesn’t create duplicates.

Events flow out through subscriptions. A catch-up subscription reads from a position the client tracks and then follows new events live. A persistent subscription keeps its position on the server and spreads events over a consumer group (competing consumers), with at-least-once delivery. Projections, written in JavaScript and run inside the server, react to JSON events and write or link them into new streams; five built-in ones, such as $by_category, group events by stream prefix or event type. The server is written in C#, runs self-hosted on Linux, Windows, macOS or Docker or as Kurrent Cloud, and has official clients for Python, Java, .NET, Node.js, Go and Rust.

Event Store Ltd renamed itself Kurrent in December 2024, and EventStoreDB became KurrentDB with version 25.0 in March 2025.

Why teams pick it

  • Made for event sourcing: per-entity streams, an expected-version check on every append and idempotent retries are built in
  • Catch-up and persistent subscriptions feed read models and other services from the same log, with server-side checkpoints and consumer groups for the latter
  • Server-side projections and system projections can regroup events into new streams without extra infrastructure
  • From 26.2, a single node gets every licensed feature that doesn’t need more nodes, without a license key

Watch out for

  • Source available, not open source: the Kurrent License v1 forbids offering it to others as a hosted service
  • From 26.2, every multi-node deployment, including high-availability clusters and read-only replicas, requires an Enterprise license
  • Writes go only to the cluster’s leader node
  • You can’t delete one event from the middle of a stream; you can only truncate it, cap it by age or count, or delete the whole stream
  • Projections only work on JSON events, and Kurrent itself points many read-model problems to a catch-up subscription feeding another database instead

Alternatives

What all event sourcing have in common →
Axon FrameworkOpen sourceA Java framework, not a database, for building event-sourced applications with CQRS and domain-driven design: commands, events and queries as messages, plus an event store to keep the events in.

How it fits with other technologies

Append with an expected version, read the stream back, and lose a race (Python client) · python

# pip install "kurrentdbclient~=1.3"; server: docker.kurrent.io/kurrent-lts/kurrentdb with --insecure
from kurrentdbclient import KurrentDBClient, NewEvent, StreamState
from kurrentdbclient.exceptions import WrongCurrentVersionError

client = KurrentDBClient("kurrentdb://127.0.0.1:2113?tls=false")

client.append_to_stream(
    stream_name="order-123",
    events=[NewEvent(type="OrderPlaced", data=b'{"total": 40}')],
    current_version=StreamState.NO_STREAM,  # the stream must not exist yet
)

events = client.get_stream(stream_name="order-123")  # replay these to rebuild the order
version = events[-1].stream_position  # 0

client.append_to_stream("order-123", events=[NewEvent(type="OrderPaid", data=b"{}")],
                        current_version=version)
try:  # a second writer that also read version 0
    client.append_to_stream("order-123", events=[NewEvent(type="OrderCancelled", data=b"{}")],
                            current_version=version)
except WrongCurrentVersionError:
    print("stream moved on: reload and decide again")

See it in a real stack

No architecture uses KurrentDB yet. Drop it into the playground and wire it up yourself.Open playground →
Where it came from2012–2026

Event Store was first released in September 2012, as open source under a 3-clause BSD license. Its lead architect was Greg Young, the consultant who coined the term CQRS, and its event processing grew from his interest in “temporal correlation queries”: questions that link things that happened at different times, written in JavaScript over streams of events.

The business moved away from open source in steps. In September 2024 Event Store announced that EventStoreDB 24.10 would ship under the Event Store License v2, based on the Elastic License v2: one binary for everyone, with enterprise features unlocked by a license key. In December 2024 the company renamed itself Kurrent and raised $12 million in a round led by Crane Venture Partners; CEO Kirk Dunn said the name describes data flowing like an electrical current through a company. KurrentDB 25.0, in March 2025, was the first release under the new name and the new Kurrent License v1.

In 2026 Kurrent changed what the free edition covers. From 26.2 the old Paxos-derived clustering is replaced by Raft, which sits in the licensed edition, so every multi-node deployment needs an Enterprise license, while single nodes get almost all other licensed features for free.

Why it’s built this way

One global log, with streams as the unit you read and lock
Every event is appended once to the log and to its stream at the same time. Fine-grained streams per entity make reads fast and give each entity its own optimistic concurrency check, while the global log keeps a single order for subscribers that want everything.
Subscriptions both client-side and server-side
Catch-up subscriptions keep their position in the client and process events in order; persistent subscriptions keep it on the server so a group of consumers can share the work, at the price of events arriving out of order within a window.
Projections inside the database
Kurrent built projections for “temporal correlation queries”, such as finding patients who got one treatment within three weeks of a diagnosis, and runs them continuously so their output is just another stream.
A license key instead of separate builds
Since September 2024 everyone downloads the same package and source stays public, while a key turns on the paid features, which Kurrent says funds continued development.

Timeline

  1. 2012

    Event Store first released as open source (BSD 3-clause)

  2. 2024

    September: EventStoreDB 24.10 announced under the Event Store License v2

  3. 2024

    December: Event Store renames itself Kurrent and raises $12M

  4. 2025

    KurrentDB 25.0, the first release under the new name, adds archiving

  5. 2026

    26.2 moves clustering to Raft and makes multi-node a licensed feature

Sources17 · facts checked 8 October 2026

Improve this page on GitHub