Versioned streams
Store events in ordered streams. Use stream versions for optimistic concurrency and idempotency keys when retrying appends.

Record changes as domain events and reconstruct aggregate state from their sequence. Chronacta provides event streams, optimistic concurrency, subscriptions, and projections—all in your infrastructure.
Why Chronacta
The API is built around streams and versions, so you do not have to implement event-store operations on top of a general-purpose database.
Appends carry an expected stream version. If the stream has already changed, Chronacta rejects the write so the application can handle the conflict explicitly.
Projections prepare data for queries. When projection logic changes, derived models can be rebuilt from the stored events.
Chronacta runs on infrastructure you manage. The open single-node edition covers one host; Enterprise adds high availability and broader operational tooling.
Capabilities
Chronacta is an event-store server. Your application handles commands and enforces aggregate invariants; Chronacta stores the resulting events and makes them available to readers, projections, and subscribers.
Store events in ordered streams. Use stream versions for optimistic concurrency and idempotency keys when retrying appends.
Read one stream or the global event log. Use durable subscriptions to retain consumer progress across restarts.
Process stored events to build read models. Replay the relevant history to rebuild derived data.
Start with Chronacta on one node. Enterprise adds high availability, security integrations, and broader operational tooling.
Use cases
With Event Sourcing, events are the source of truth, not an additional audit record. The application derives aggregate state from those events, while projections build read models for queries. This approach is useful when domain transitions matter to the system.
Model order placement, line changes, cancellations, and shipments as distinct domain events governed by aggregate invariants.
Represent financial operations explicitly and derive balances or other read models from the recorded events.
Reconstruct the transitions that led to a case's current state and apply domain rules to subsequent commands.
Build lists, reports, and search indexes from the same event history without changing the aggregate's event stream.
Example
A command handler receives a request to ship an order. It loads the order aggregate, reconstructs its state from events, and asks the aggregate to validate the operation. If the rules allow shipment, the application appends OrderShipped with the expected stream version. Chronacta records the event. A projection updates the order list, and a subscriber can notify another service.
Domain rules remain in the application. Chronacta provides the storage and delivery mechanisms needed to use domain events as the source of truth.
Get started
Start with a concrete domain operation and test the complete path from a command to an updated read model.
Identify the aggregate, its invariants, the commands it accepts, and the events that describe its state transitions.
Run the server, append events with an expected version, and reconstruct aggregate state by reading the stream.
Build a read model for queries. Test consumer restarts, duplicate delivery, and rebuilding derived data.
Evaluate capacity, recovery, and availability requirements. Stay on Chronacta or consider Enterprise according to those requirements.
Explore the architecture, compare deployment options, or start implementing your first event stream.