Version compatibility

Cratis spans .NET packages, TypeScript packages, JVM and Elixir clients, Docker images, storage engines, and React components. This page records the baseline the current product sources declare, and how the products constrain each other’s versions. For exact released package versions, use the package manager and the repository release pages linked from What’s new.

Review releases Use curated release digests and repository releases for exact published versions.

Plan an upgrade See every Chronicle major boundary between the version you run and the one you want.

Ask about a version Use Discord when a specific runtime or package version matters to your project.

Current baseline

Area	Baseline
.NET local development	.NET 10 is the development target in Chronicle, Arc, Fundamentals, and CLI source.
.NET package targeting	Arc and Fundamentals package for net8.0, net9.0, and net10.0. Chronicle’s packaging configuration targets the same three frameworks.
.NET web template	The current dotnet new cratis template targets net10.0 and requires the .NET 10 SDK. In the template source, the Cratis package references use Version="*". When you scaffold, the template’s post-actions run dotnet add package for those packages, which writes the then-current released version into your project file. A new project therefore starts pinned to concrete NuGet versions, not floating ones. Library multi-targeting does not mean the template supports every target.
Frontend packages in the web template	package.json uses caret ranges, such as ^22.10.4 for the @cratis/arc packages and ^4.1.1 for @cratis/components. Your package manager resolves the newest release inside each range when it installs, independently of the NuGet versions the backend was pinned to.
Kotlin and Java templates	The templates use latest.release for the Arc Gradle plugin and the io.cratis:cratis meta package, with dependency management enabled. Inspect the resolved dependencies before choosing production versions.
Go modules	Chronicle.Go, Arc.Go, and Fundamentals.Go require Go 1.26 or later. Fundamentals.Go v0.3.2 installs with go get github.com/cratis/fundamentals.go@v0.3.2.
CLI	The cratis CLI targets net10.0.
Node.js for applications	The full-stack web template’s README asks for Node.js ^20.19.0 or >=22.12.0. Individual samples list their own Node.js requirement.
Node.js for contributors	The Arc, Components, and Fundamentals repositories declare node >=23.0.0 for their own workspaces.
Package manager	The JavaScript repositories use Yarn 4 and pin the exact version in each repository’s packageManager field. The web template works with yarn, pnpm, or npm.
React	@cratis/arc.react declares React 18 or 19 as a peer. @cratis/components declares React 19 (^19.0.0).
TypeScript	The web template’s frontend build uses the TypeScript 7 compiler (@typescript/native), with a TypeScript 6 alias kept for tooling. The Components and Fundamentals repositories build with TypeScript 6; the Arc repository builds with TypeScript 7.
Chronicle Kotlin/Java client	The JVM client (io.cratis:chronicle on Maven Central) builds with a JVM 17 toolchain and ships a Spring Boot starter (io.cratis:chronicle-spring-boot-starter) and a testing library.
Chronicle Elixir client	The Elixir client (cratis_chronicle on Hex) declares Elixir ~> 1.18 (Elixir 1.18 or later, which its googleapis dependency requires) and installs through mix.
Chronicle storage	MongoDB, PostgreSQL, Microsoft SQL Server, and SQLite are documented storage choices.
Arc persistence	MongoDB and Entity Framework Core integrations are documented for C#; Spring Data MongoDB and Spring Data JPA for Kotlin and Java.

Support matrix

Chronicle runs on four storage backends, has clients for four languages, and runs in Docker or under .NET Aspire; the tables below give each option and its maturity. Released means the product publishes packages or images; the sources state no further maturity label. The Cratis Stack lists every product.

Area	Option	Maturity	Notes
Chronicle storage	MongoDB	Released, default	Run as a replica set, even with one node.
Chronicle storage	PostgreSQL	Released	Documented storage choice.
Chronicle storage	Microsoft SQL Server	Released	Documented storage choice.
Chronicle storage	SQLite	Released	Documented storage choice.
Chronicle storage	In-memory	Not durable	For tests, samples, and ephemeral environments only.
Chronicle client	.NET	Released, first-class	Cratis.Chronicle on NuGet.
Chronicle client	TypeScript and Node.js	Released	@cratis/chronicle on npm.
Chronicle client	Kotlin and Java	Released	io.cratis:chronicle on Maven Central.
Chronicle client	Elixir	Released	cratis_chronicle on Hex.
Chronicle client	Go	Experimental	v0.11.0, a v0.x foundation: no observers or projections yet. Install with go get github.com/cratis/chronicle.go@v0.11.0.
Chronicle client	Python	Pre-alpha	Not published.
Arc backend	C# on ASP.NET Core	Released
Arc backend	Kotlin and Java on Spring Boot	Released
Arc backend	TypeScript on Node.js	Source preview	No package is published.
Arc backend	Go	Early development	v0.1.1; the API remains experimental. Install with go get github.com/cratis/arc.go@v0.1.1.
Frontend	React	Released	Arc React packages accept React 18 or 19; Components requires React 19.
.NET	.NET 8, 9, and 10	Released	Arc and Fundamentals package for all three; Chronicle’s packaging targets the same. The CLI and the dotnet new cratis template target .NET 10.
Hosting	Docker	Released	cratis/chronicle image; the latest-development image bundles MongoDB and is for development and CI only.
Hosting	Docker Compose	Documented	See Docker Compose hosting.
Hosting	.NET Aspire	Released	Cratis.Chronicle.Aspire package; a .NET hosting option only.

Model-first tools (Screenplay, Stage, Prologue) are experimental and Studio is in Preview; see the capability map. The kernel can also run wherever you operate containers, such as Kubernetes; the docs describe Docker, Compose, and Aspire topologies and give no Kubernetes deployment guide.

Product relationships

Product	Common dependency relationship
Chronicle	Uses Fundamentals and Arc packages internally, exposes a first-class .NET client plus TypeScript, Kotlin/Java, and Elixir clients (and an experimental Go client) over gRPC/protobuf contracts, and can be inspected through the CLI and Workbench.
Arc	Uses Fundamentals and can integrate with Chronicle, MongoDB, Entity Framework Core, ASP.NET Core, OpenAPI, Swagger, and generated TypeScript proxies.
Components	Renders Arc’s generated command and query proxies in React. Since Components 4 it owns its markup, types, and styling contract and uses React Aria internally; it no longer depends on PrimeReact. See UI foundation.
CLI	Talks to Chronicle, installs managed AI guidance with cratis ai, and writes a CLI command catalog for AI assistants with cratis init.
Documentation	Aggregates product Documentation/ folders and builds Storybook/API reference artifacts into the site.

Which pairings are verified

There is no single numbered matrix that says which Chronicle kernel, Chronicle client, Arc, and Components versions work together. These are the constraints the products state today:

Pairing	What is established
Chronicle kernel and the .NET client	The .NET client shares the kernel’s version number. Within one major version, Chronicle verifies that the current build serves every released minor of that major. Across a major boundary, move the kernel and the client together unless the upgrade guide says the boundary is wire-compatible. Upgrading across major versions lists every boundary, and marks the ones it cannot describe as unknown.
Chronicle kernel and the TypeScript, Kotlin/Java, and Elixir clients	These clients have their own version numbers, so a client’s major version says nothing about which kernel major it matches. Instead, the client sends its compiled contract descriptors when it connects, and the kernel compares them structurally with its own. Additions on the server side are allowed; a removed or changed service, message, or field fails the connection with an incompatibility error. There is no published table pairing a given client release with kernel versions. See the wire-compatibility handshake.
Components and Arc	Components states its supported Arc range in its peerDependencies. In the current Components 4 source, that is @cratis/arc and @cratis/arc.react >=20.3.1 <23, with @cratis/fundamentals ^7.10.3. Check the package.json of the Components version you install.
Arc, Chronicle, and the JVM templates	The Kotlin and Java templates resolve the Cratis meta package and Arc Gradle plugin dynamically. Their source does not establish a fixed, verified Arc/Chronicle version pairing.
Arc and Chronicle on .NET	The Cratis meta package brings a matching Arc and Chronicle client together; the .NET templates add its latest release when you scaffold. Other version combinations are not documented as verified.

If your combination is not in this table, treat it as unverified rather than as known to work or known to fail, and ask in Community and help before depending on it.

How to verify your stack

1. Check the package versions you plan to install, including the peer ranges your package manager reports.
2. Check the matching release notes in What’s new.
3. For Chronicle, check Plan an upgrade for any major boundary between the kernel and the client versions you run.
4. Check the product guide for runtime-specific setup.
5. Pin container images and package versions in production.
6. Ask in Community and help if your runtime combination is not listed.

Do not rely on latest tags in production

Use explicit package versions and Docker image tags for deployed systems. The Chronicle hosting docs also recommend specific version tags for production deployments. The .NET templates pin concrete NuGet versions when you scaffold, but the frontend caret ranges and the JVM templates’ latest.release still float. Commit a lockfile and pin the resolved packages and plugins before you deploy.