This matrix covers two backend implementations: C# on ASP.NET Core, and
Kotlin and Java on Spring Boot. Use this page to check whether a
capability exists in the language you work in before you design around it.
Each cell was checked against that implementation’s source, public API, and tests, not
against its documentation. A cell says a capability exists. It does not say the two
implementations behave identically: where both have a capability but it differs on the wire,
where the implementations differ
describes the difference. The Kotlin and Java evidence behind every row, including which test
proves it, is in the JVM parity reference.
The capability exists in the current source and public API and is usable from this language.
Partial
Usable, with the boundary stated in the notes.
Not planned
Absent from source, and recorded as not planned for that implementation.
Not applicable
The capability belongs to another platform’s host or toolchain.
A capability one implementation has and the other has neither built nor ruled out is not
forced into these states. It is listed under
not yet in every implementation.
Kotlin and Java share one runtime. The Java column counts capabilities usable through
Java-callable APIs; language-specific verification limits are stated separately. Java uses
annotations on Java types, CompletionStage and Flow.Publisher returns, static query
methods, and the Blocking* and Async* contracts rather than implementing suspending methods.
Not every Java contract is discovered the same way:
Collected as Spring beans directly:AsyncAuthenticationHandler,
AsyncIdentityDetailsProvider, AsyncUsersProvider, AsyncTenantsProvider,
ConceptValidator, and BlockingQueryRendererFor, BlockingReadModelInterceptor,
BlockingObservableQueryEmissionGuard, and BlockingReadModelForCommandResolver, which
extend the Kotlin contracts.
Run only through an adapter bean you declare: command and query filters, authorization
filters and named policies, command and query validators, command execution scopes, and
command response value handlers. Wrap the Java implementation in the matching
Blocking*Adapter or Async*Adapter from io.cratis.arc.java and return it from a @Bean
method. A class that implements BlockingCommandFilter without that bean is never called.
See pipeline filters.
Provide/provide loads data after filters pass and hands it to the handler. C# · Kotlin and Java
Command keys
Implemented
Implemented
Implemented
C# ICanProvideKeyForCommand; JVM @CommandKey and CommandKeyProvider. C# · Kotlin and Java
Several return values
Implemented
Implemented
Implemented
C# tuples; JVM Pair, Triple, CommandProvidedValues, and CommandResponseValues. Exactly one value may reach the client on the JVM. C#
Alternative return values
Implemented
Implemented
Implemented
C# OneOf values; JVM ArcOneOf. Java can build an ArcOneOf through its static of and alternative factories, but no Java-authored test returns one. Generating named union types (@GenerateOneOf) is not planned on the JVM.
C# ISubject<T>/IObservable<T>; Kotlin Flow/StateFlow; Java Flow.Publisher and ObservableState. C# · Kotlin and Java
Observable transports
Implemented
Implemented
Implemented
HTTP snapshot, direct SSE and WebSocket, and the multiplexed hubs. The JVM transport code is shared; its SSE and WebSocket runtime tests run against the Kotlin sample. Snapshot readiness differs; see the HTTP contract.
Paging and sorting
Implemented
Implemented
Implemented
The result shapes that get paged differ. C# pages and sorts an IQueryable result through QueryableQueryRenderer. The JVM’s default fallback pages and sorts Iterable results in memory when no custom renderer matches; custom renderers own their paging and sorting. QueryPage and Spring Data Page results pass through; a returned array is not sorted or paged, and its paging totals stay at zero. C# · Kotlin and Java
Warnings and information alongside errors, and treating warnings as errors. C# · Kotlin and Java
Concept validators
Implemented
Implemented
Implemented
One rule for a concept, applied wherever the concept appears. C# · Kotlin and Java
Annotation rules in generated proxies
Implemented
Implemented
Implemented
C# DataAnnotations; JVM Jakarta Bean Validation, which covers more annotations. C# · Kotlin and Java
Validator rules shared with the client
Implemented
Implemented
Implemented
Each side sends only the rules it recognizes. C# extracts the FluentValidation rules its proxy generator knows; the JVM FluentModelValidator<T> supports thirteen literal rules and no warning severity. C# · Kotlin and Java
Opting one member out of validation
Partial
Implemented
Implemented
C# [IgnoreValidation] applies to a controller class or action, not to a model-bound artifact or one member; one member can skip concept validators with IgnoreConceptRules(). JVM @IgnoreValidation skips one member and everything below it. Kotlin and Java
An operation’s own declaration replaces its type’s. C# · Kotlin and Java
Named policies and authentication schemes
Implemented
Implemented
Implemented
C# runs scoped asynchronous native policies on either host and ASP.NET Core policies on that host. Actual scheme authentication requires ASP.NET Core and an Arc-owned execution scope; standalone Core rejects scheme requirements. The JVM checks the caller’s already-captured scheme rather than authenticating another scheme. Java policies need an adapter bean. C# policies · C# scheme boundaries · Kotlin and Java
x-ms-client-principal. Ignored on C# until the host sets TrustForwardedIdentityHeaders. Off by default on the JVM; enabling it also requires an application ArcPlatformIdentityTrust bean because the default trusts no request. C# · Kotlin and Java
C# observes MongoDB collections and EF Core sets. The JVM uses MongoDB change streams, which need a replica set or sharded cluster, and explicit in-process JPA notifications. C# · Kotlin and Java
Read models in command handlers
Implemented
Implemented
Implemented
Arc resolves a read model by command key and hands it to the handler. C# · Kotlin and Java
Both let a reactor declare the system roles its commands run with through ExecuteCommandsAsSystem. A JVM reactor hands command values to ChronicleCommandSideEffectHandler. C# · Kotlin and Java
Chronicle command scenarios
Implemented
Implemented
Implemented
An in-memory event log; no Chronicle kernel runs. C# · Kotlin and Java
C# has command and snapshot query scenarios, but no observable-query scenario. The JVM has command, query, and observable query scenarios; Java uses the Blocking* and Async* scenario classes. C# commands · C# queries · Kotlin and Java
These C# capabilities have no Kotlin or Java counterpart in source, and no decision records
them as not planned for the JVM. They are listed here rather than marked not planned.
The JVM parity reference also tracks rows that describe how the JVM is verified rather than a
capability you adopt: the proxy differential gates, the runtime and HTTP conformance gates,
binary compatibility, runtime hardening, Kotlin ergonomics, and the Java adapters themselves.
It records cross-store transactions as not planned; neither implementation provides one.
Admission control and request limits are compared in
the HTTP contract.