---
title: "Event sourcing on the JVM: comparing Axon, KurrentDB, and Cratis Chronicle"
description: "A version-pinned, source-cited comparison of event sourcing options for Kotlin and Java — Axon Framework 5.3.1 with Axon Server, KurrentDB 26.0 with the io.kurrent:kurrentdb-client 1.2.1 Java client, and Cratis Chronicle 17.0.0 with the io.cratis:chronicle 2.10.0 JVM client and its Spring Boot starter — covering license, storage model, programming model, Spring Boot integration, subscriptions, projections, hosting, and each tool's wider ecosystem, with citations and retrieval dates for every row."
head:
  - tag: meta
    attrs:
      name: keywords
      content: "event sourcing JVM comparison, event sourcing Kotlin, event sourcing Java, Axon Framework vs KurrentDB vs Cratis Chronicle, Axon Framework alternatives, event store Java comparison, Kotlin event sourcing framework, Spring Boot event sourcing, choosing an event sourcing framework for the JVM, event sourcing database Java"
---

import { Aside } from '@astrojs/starlight/components';

Choosing an event sourcing foundation for a JVM system is a long-lived decision. The event store outlives frameworks, UI rewrites, and often the team that chose it. Yet most comparisons available today reduce to popularity: the tools with the most blog posts win the evaluation before it starts.

This comparison takes the same approach as our [.NET comparison](/compare-event-sourcing-dotnet/): every factual row names the exact versions compared and is reproducible from public documentation and released packages. Where our own product appears, the same rules apply — including the limitations.

## The candidates

- **Axon Framework (with Axon Server)** — a JVM framework for building applications based on Domain-Driven Design, CQRS, and event sourcing, with a pluggable event storage engine. Axon Server is its default event store and message bus, run as a separate server.
- **KurrentDB (formerly EventStoreDB) with the Java client** — a purpose-built event store database with an official gRPC Java client for JVM languages. You bring your own CQRS layer and read-model infrastructure.
- **Cratis Chronicle with the JVM client** — an event-sourcing database and processing runtime with a JVM client usable from both Kotlin and Java (`io.cratis:chronicle`), plus a Spring Boot starter that reduces setup to a dependency. The same server is reachable from the released [.NET, TypeScript, and Elixir clients](/chronicle-clients/).

## How this comparison is made

<Aside type="note" title="Method">
Every row states a released, verifiable capability fact. Every cell is cited from the named tool's own public documentation, repository, or public package-registry listing for its released packages, with the retrieval date recorded. No cell states or implies performance, scalability, maturity, reliability, popularity, production-suitability, or superiority — for any tool, including Cratis Chronicle. Any reader can reproduce every cell from the cited source at the named version.
</Aside>

## Compared versions

All facts retrieved **2026-08-29** unless a row states otherwise.

| Tool | Compared version | Version source |
| ---- | ---------------- | -------------- |
| Axon Framework | 5.3.1 (latest release on Maven Central at retrieval); documentation cited from the 5.3 reference series. Axon Server documentation cited from its current installation documentation | [Maven Central metadata for `org.axonframework:axon-messaging`](https://repo1.maven.org/maven2/org/axonframework/axon-messaging/maven-metadata.xml); [docs.axoniq.io/axon-framework-reference/5.3/](https://docs.axoniq.io/axon-framework-reference/5.3/events/infrastructure/) (retrieved 2026-08-29) |
| KurrentDB (formerly EventStoreDB) | Server 26.0 documentation series; 26.0.3 is the release named in the official installation documentation. Java client `io.kurrent:kurrentdb-client` 1.2.1 (latest release on Maven Central at retrieval) | [docs.kurrent.io/server/v26.0/quick-start/installation.html](https://docs.kurrent.io/server/v26.0/quick-start/installation.html); [Maven Central metadata for `io.kurrent:kurrentdb-client`](https://repo1.maven.org/maven2/io/kurrent/kurrentdb-client/maven-metadata.xml) (retrieved 2026-08-29) |
| Cratis Chronicle | Server 17.0.0 (latest stable `Cratis.Chronicle` package on NuGet at retrieval), distributed as the `cratis/chronicle` Docker image. JVM client `io.cratis:chronicle` 2.10.0 (latest release on Maven Central at retrieval) | [nuget.org listing for `Cratis.Chronicle`](https://www.nuget.org/packages/Cratis.Chronicle); [hub.docker.com/r/cratis/chronicle](https://hub.docker.com/r/cratis/chronicle); [Maven Central metadata for `io.cratis:chronicle`](https://repo1.maven.org/maven2/io/cratis/chronicle/maven-metadata.xml) (retrieved 2026-08-29) |

## The comparison matrix

| Row | Axon Framework (5.3.1) | KurrentDB (server 26.0, Java client 1.2.1) | Cratis Chronicle (17.0.0, JVM client 2.10.0) |
| --- | ---------------------- | ------------------------------------------ | -------------------------------------------- |
| License | Axon Framework is licensed under the Apache License 2.0 (repository `LICENSE.txt`). Axon Server ships as a single artifact that "will now automatically adjust" depending on the presence of a license; the AxonIQ Developer edition is documented as "entirely free to use" and "limited to a single node", with paid Professional and Enterprise editions. | Server: Kurrent License v1 (KLv1). The KurrentDB documentation states the source code is available to view and that KLv1 "is not an OSI-approved Open Source License"; enterprise features are enabled with a license key. Java client: Apache License 2.0 (repository `LICENSE`). | MIT License, for both the server and the JVM client (repository `LICENSE` files). |
| Storage model | Framework with a pluggable `EventStorageEngine`. Documented engines at 5.3: `AxonServerEventStorageEngine` (default when using Axon Server), `PostgresqlEventStorageEngine` (stores events directly in a PostgreSQL 16+ database; the default engine when running without Axon Server), `AggregateBasedJpaEventStorageEngine` (JPA-compatible databases), and an in-memory engine for testing. "The default Event Bus (and Event Store) is Axon Server." | Purpose-built, event-native database; events are stored in streams inside KurrentDB's own storage engine. | Event-sourcing database with a documented MongoDB storage backend and "an extensible model for other data stores" (repository README wording). |
| JVM programming model | Building blocks for DDD, CQRS, and event sourcing running inside your JVM application: command, event, and query handlers, event-sourced entities (declarative, `@EventSourcedEntity`, or `@EventSourced` with Spring Boot), command routing, and repositories. | Client SDK "written in Java for use with languages on the JVM", compatible with Java 8 and above; GA versions published to Maven Central. The Java client is one of the official gRPC client SDKs listed in the server documentation. Application-layer patterns such as aggregates and CQRS are built in your own code on top of the client. | One artifact usable from both Kotlin and Java: events are data classes or records with `@EventType`, read models are classes with `@ReadModel`, and reducers, reactors, projections, and constraints follow the same annotation pattern. Artifacts on the classpath are discovered and registered with the kernel on connect. Kotlin gets suspending calls; Java gets blocking bridges for the same surface. |
| Spring Boot integration | Official Spring Boot starter `org.axonframework.extensions.spring:axon-spring-boot-starter`. Auto-configuration detects and registers message handlers (`@CommandHandler`, `@EventHandler`, `@QueryHandler`) and `@EventSourced` entities, configures the buses and event processors, and ties Axon's lifecycle to the Spring context. | No entry compiled for this row; per the caveats, absence means only that it was not found in the sources cited for this page. | Official Spring Boot starter `io.cratis:chronicle-spring-boot-starter`. The starter brings the client, discovers and registers artifacts in the application's packages before the first request is served, activates artifacts through the Spring container, and gives every request an identity, a causation trail, and a unit of work, with documented multi-tenant routing from a header, a subdomain, or a claim. |
| Subscriptions / event processing | Event processors in two forms: subscribing (invoked by the publishing mechanism's thread, or fed by an Axon Server persistent stream) and streaming (pull events using tracking tokens). The default processor is the `PooledStreamingEventProcessor`, with segmented parallel processing and replay support via reset tokens. | Catch-up subscriptions (client keeps position) and persistent subscriptions (server keeps position, competing-consumers pattern, at-least-once delivery across consumer groups), served over gRPC to the official clients. | Reactors (react to events as they occur), Reducers (transform events into typed read models), and Observers (low-level event subscriptions with guaranteed delivery), as documented in the server repository README; the JVM client declares reactors and reducers with `@Reactor` and `@Reducer` annotations. |
| Projections / read models | Read models are maintained by event handling components assigned to event processors; streaming processors support replays (reset tokens with `@ResetHandler` hooks) to rebuild them. | Server-side projections subsystem: built-in (system) projections and user-defined JavaScript projections; projections require the event body to be JSON. The docs note many read-model problems are better served by a separate read model populated by a catch-up subscription. | Declarative projections declared from the JVM client with `IProjectionFor<T>` or `@FromEvent` on the read model, producing typed read models retrievable by key through the client. |
| Hosting model | The framework runs inside your JVM application. Axon Server is a separate server process: a single artifact installable by download, Docker, Docker Compose, Kubernetes, or Linux packages, whose available features depend on the presence of a license; the free Developer edition is limited to a single node. Running without Axon Server against PostgreSQL is documented at 5.3. | Separate database server process: single node or a highly-available cluster (three nodes for cluster deployment); installable from Linux package repositories, on Windows via Chocolatey, via Docker images, or on Kubernetes via the Operator; some features require a license key. | Separate server (Chronicle Kernel) run via the `cratis/chronicle` Docker image, exposing gRPC, REST API, and the Web Workbench management dashboard on a single port; the `latest-development` image bundles MongoDB for local development. |

### Row sources

All retrieved 2026-08-29:

- **Axon Framework / Axon Server** — framework identity and positioning: [github.com/AxonIQ/AxonFramework `README.md`](https://github.com/AxonIQ/AxonFramework/blob/master/README.md); license: [github.com/AxonIQ/AxonFramework `LICENSE.txt`](https://github.com/AxonIQ/AxonFramework/blob/master/LICENSE.txt) (Apache-2.0); event store, storage engines, default event bus/store, multi-context: [docs.axoniq.io/axon-framework-reference/5.3/events/infrastructure/](https://docs.axoniq.io/axon-framework-reference/5.3/events/infrastructure/); event processors, subscribing/streaming, replay: [docs.axoniq.io/axon-framework-reference/5.2/events/event-processors/](https://docs.axoniq.io/axon-framework-reference/5.2/events/event-processors/) and [docs.axoniq.io/axon-framework-reference/5.3/events/event-processors/subscribing/](https://docs.axoniq.io/axon-framework-reference/5.3/events/event-processors/subscribing/); event-sourced entities: [docs.axoniq.io/axon-framework-reference/5.0/commands/entities/event-sourced-entity/](https://docs.axoniq.io/axon-framework-reference/5.0/commands/entities/event-sourced-entity/); Spring Boot starter and component detection: [docs.axoniq.io/axon-framework-reference/5.3/spring-boot-integration/](https://docs.axoniq.io/axon-framework-reference/5.3/spring-boot-integration/) and [docs.axoniq.io/axon-framework-reference/5.3/configuration/spring/](https://docs.axoniq.io/axon-framework-reference/5.3/configuration/spring/); Axon Server editions, single artifact, license behavior, install channels: [docs.axoniq.io/axon-server-installation/](https://docs.axoniq.io/axon-server-installation/), [docs.axoniq.io/axon-server-installation/developer/](https://docs.axoniq.io/axon-server-installation/developer/), and [docs.axoniq.io/axon-server-reference/v2026.1/axon-server/installation/local-installation/](https://docs.axoniq.io/axon-server-reference/v2026.1/axon-server/installation/local-installation/); framework version: [Maven Central metadata for `org.axonframework:axon-messaging`](https://repo1.maven.org/maven2/org/axonframework/axon-messaging/maven-metadata.xml) (5.3.1).
- **KurrentDB** — server license, official client list including Java, protocols: [docs.kurrent.io/server/v26.0/quick-start/](https://docs.kurrent.io/server/v26.0/quick-start/) (Introduction); hosting, packages, Docker, Kubernetes Operator, license keys, 26.0.3: [docs.kurrent.io/server/v26.0/quick-start/installation.html](https://docs.kurrent.io/server/v26.0/quick-start/installation.html); projections: [docs.kurrent.io/server/v26.0/features/projections/](https://docs.kurrent.io/server/v26.0/features/projections/); persistent subscriptions: [docs.kurrent.io/server/v26.0/features/persistent-subscriptions.html](https://docs.kurrent.io/server/v26.0/features/persistent-subscriptions.html); Java client identity, Java 8+, Maven Central, server compatibility: [github.com/kurrent-io/KurrentDB-Client-Java `README.md`](https://github.com/kurrent-io/KurrentDB-Client-Java/blob/trunk/README.md); Java client license: [github.com/kurrent-io/KurrentDB-Client-Java `LICENSE`](https://github.com/kurrent-io/KurrentDB-Client-Java/blob/trunk/LICENSE) (Apache-2.0); client version: [Maven Central metadata for `io.kurrent:kurrentdb-client`](https://repo1.maven.org/maven2/io/kurrent/kurrentdb-client/maven-metadata.xml) (1.2.1).
- **Cratis Chronicle** — server identity, MongoDB backend, reactors/reducers/projections/observers, Docker hosting, Workbench: [github.com/Cratis/Chronicle `README.md`](https://github.com/Cratis/Chronicle/blob/main/README.md); server license: [github.com/Cratis/Chronicle `LICENSE`](https://github.com/Cratis/Chronicle/blob/main/LICENSE) (MIT); JVM client identity, annotations, discovery, coroutines and Java bridges, Spring Boot starter, testing module, license: [github.com/Cratis/Chronicle.Kotlin `README.md`](https://github.com/Cratis/Chronicle.Kotlin/blob/main/README.md) and [`LICENSE`](https://github.com/Cratis/Chronicle.Kotlin/blob/main/LICENSE) (MIT); versions: [nuget.org](https://www.nuget.org/packages/Cratis.Chronicle) (`Cratis.Chronicle` 17.0.0), [Maven Central metadata for `io.cratis:chronicle`](https://repo1.maven.org/maven2/io/cratis/chronicle/maven-metadata.xml) (2.10.0), [hub.docker.com/r/cratis/chronicle](https://hub.docker.com/r/cratis/chronicle).

## Ecosystem and supporting products

An event store rarely ships alone. Each of the compared tools names its own supporting products; the same method applies here — every cell restates the named vendor's own public listing or documentation, with retrieval dates, and implies nothing about quality, integration depth, or superiority.

| Row | Axon Framework (5.3.1) | KurrentDB (server 26.0, Java client 1.2.1) | Cratis Chronicle (17.0.0, JVM client 2.10.0) |
| --- | ---------------------- | ------------------------------------------ | -------------------------------------------- |
| Wider product family | The framework README names Axon Server ("a distributed command bus, event bus, query bus, and an efficient event store implementation for scalable event sourcing") and states the Axon Framework organization "has several extensions". The Axon Server documentation names the Axoniq Platform: connecting Axon Server to it "can unlock additional functionality" and "is all free up to 10 connected applications at a time". | Official gRPC client SDKs listed for Python, Node.js (JavaScript/TypeScript), Java, .NET, Go, and Rust; community clients listed for Ruby, Elixir, and PHP; the documented server feature set includes projections, persistent subscriptions, and a Connectors subsystem (next row). | Part of the Cratis ecosystem: [Arc](/arc/) (an opinionated CQRS application framework for ASP.NET Core with commands, queries, validation, authorization, and TypeScript proxy generation), [Components](/components/) (a React component library aligned with Arc application patterns), the [Cratis CLI](/cli/) (terminal workflows for inspecting and diagnosing Chronicle), and the Web Workbench management dashboard exposed by the server. Released clients for .NET, TypeScript, JVM, and Elixir; AI agents connect through the [Chronicle MCP server](/ai/). |
| Pushing events to other systems | Event handling components run by event processors react to events in the application; the framework documentation describes Axon Server's Multi-Context solution for distributing events between bounded contexts. | Server-side Connectors subsystem, documented as pre-installed and enabled by default: each connector runs a catch-up subscription that can filter or transform events and push them to an external system via a sink. | The server exposes gRPC and REST APIs (see the Hosting model row); Reactors provide documented event-driven processing, and the JVM client documents webhook definers that push events "out to something beyond your process". |
| AI assistance | The framework README references "Ask Axon Guru", described as "an Axon-focused AI to answer your questions". | No entry compiled for this row; per the caveats, absence means only that it was not found in the sources cited for this page. | Cratis documents free AI skills, rules, and diagnostics for AI-assisted development on the [AI page](/ai/); the JVM client README describes the ecosystem as "AI-friendly by design". Current availability and distribution status are stated on the AI page. |

### Ecosystem row sources

All retrieved 2026-08-29:

- **Axon** — Axon Server description, extensions, Ask Axon Guru: [github.com/AxonIQ/AxonFramework `README.md`](https://github.com/AxonIQ/AxonFramework/blob/master/README.md); Axoniq Platform wording: [docs.axoniq.io/axon-server-installation/developer/](https://docs.axoniq.io/axon-server-installation/developer/); Multi-Context: [docs.axoniq.io/axon-framework-reference/5.3/events/infrastructure/](https://docs.axoniq.io/axon-framework-reference/5.3/events/infrastructure/).
- **KurrentDB** — client SDK list: [docs.kurrent.io/server/v26.0/quick-start/](https://docs.kurrent.io/server/v26.0/quick-start/); Connectors overview (pre-installed, enabled by default, catch-up subscription, filter/transform, sinks): [docs.kurrent.io/server/v26.0/features/connectors/](https://docs.kurrent.io/server/v26.0/features/connectors/).
- **Cratis Chronicle** — Arc: [cratis.io/arc/](https://cratis.io/arc/); Components: [cratis.io/components/](https://cratis.io/components/); CLI: [cratis.io/cli/](https://cratis.io/cli/); Workbench: [github.com/Cratis/Chronicle `README.md`](https://github.com/Cratis/Chronicle/blob/main/README.md); webhook definers, ecosystem listing, AI wording: [github.com/Cratis/Chronicle.Kotlin `README.md`](https://github.com/Cratis/Chronicle.Kotlin/blob/main/README.md); AI skills, rules, and diagnostics: [cratis.io/ai/](https://cratis.io/ai/).

## Caveats and limitations

- **This matrix compares documentation, not behavior.** Every cell restates what the named tool's own public documentation or registry listing says at the named version and retrieval date. It does not test, measure, or rank anything, and absence of a capability from a cell means only that it was not found in the cited source — not that the tool lacks it.
- **A framework and a database answer different questions.** Axon Framework is a framework with pluggable storage; KurrentDB and Chronicle are databases with clients. The rows state what each tool's documentation says about its own shape; they do not rank the shapes.
- **Client existence is not client parity.** A listed client package says nothing about feature coverage relative to the primary client — for any tool in this table, including Chronicle's JVM client relative to its .NET SDK.
- **An ecosystem listing is not an integration or quality claim.** The ecosystem rows restate each vendor's own product-family listing at the retrieval date. They say nothing about how well the pieces work together, how complete any supporting product is, or how the families compare — and an empty or missing entry means only that nothing was found in the cited sources.
- **Chronicle's storage-provider breadth beyond the documented MongoDB backend is not stated as a row fact.** Public Chronicle documentation at the compared version documents a MongoDB backend with an extensible storage model; the row sticks to that cited wording.
- **Licensing nuance, for two of the three.** The license rows quote each vendor's own documentation; read KLv1 and the Axon Server edition terms yourself. Axon Framework itself is Apache-2.0; Axon Server's features depend on edition and license. This page draws no conclusion about fitness of any license for any use.
- **Documentation series differ from patch versions.** Axon Framework facts are cited from the 5.3 reference series (with two rows citing 5.2 and 5.0 pages where the 5.3 page splits content); KurrentDB facts from the server v26.0 series. A patch release inside a series may change details without changing the cited page.
- **Versions move.** Each compared tool releases on its own cadence; every cell is pinned to the versions and retrieval dates above and may be stale the day after retrieval.

## How to choose

Rather than a winner, use fit questions:

- **Do you want a framework that structures your whole application, or a database behind code you structure yourself?** A DDD/CQRS framework gives you aggregates, buses, and processors as first-class citizens — and its conventions. A database with a client leaves the application architecture entirely to you.
- **Where should events live?** One candidate defaults to its own server but documents PostgreSQL and JPA storage engines; one is itself the storage engine; one is a database with a documented MongoDB backend. Which operational surface does your team already run?
- **How much of the read side do you want designed for you?** Compare writing event handling components and processors yourself against declaring reducers and projections that the server executes.
- **Is Spring Boot your baseline?** Two of the three document an official Spring Boot starter; compare what each starter actually auto-configures — handlers and buses, or discovery, tenancy, and per-request units of work.
- **Is your organization polyglot?** Check which client languages are first-party and what each client actually supports — client existence is not client parity, for any tool including ours.
- **Who explains the system at 3 a.m.?** Compare the operational surfaces: what does each tool show you about processor or observer progress, failed projections, and replay?

## What we deliberately did not claim

This comparison states released, verifiable facts. It does not claim any tool is faster, more scalable, more reliable, or more production-proven than another — those claims require benchmarks and evidence this page does not carry. Where a capability is listed for Chronicle, it comes from the named released version; the same courtesy is extended to every tool compared, from that tool's own documentation.

## How this page stays current

This matrix is re-verified — every cell checked against the then-current released versions with new retrieval dates — whenever a compared tool ships a new major or minor server/package release, a compared tool changes its license or client list, or 90 days elapse since the last recorded retrieval date. If a compared tool disputes a row and it cannot be re-verified, the row is corrected or removed.

If you spot a cell that no longer matches its source, [tell us](/feedback/) — we will re-verify and fix it.