Event sourcing you can actually be productive with
Get started in 3 steps
Section titled “Get started in 3 steps”Install the .NET templates and spin up your first full-stack Cratis app — Chronicle, Arc, and a React frontend, all wired up — in minutes.
-
Install the Cratis templates. Add the official project templates to your .NET CLI. You only need to do this once.
Terminal window dotnet new install Cratis.Templates -
Create your application. Scaffold a new app complete with Chronicle, Arc, and a React frontend.
Terminal window dotnet new cratis -n MyApp --allow-scripts Yes -
Run it. Start the supporting services, then the backend and the frontend from your new app folder.
Terminal window cd MyApp && docker compose up -ddotnet runyarn dev
Prefer a guided path? The Chronicle getting-started walkthrough takes one event through a projection and a reactor, step by step.
One feature, every layer
See the full-stack loop before you choose a product
Cratis is most different when you follow one behavior all the way through: model the domain, resolve identity and tenant at the edge, build the slice, record the event, render the React screen, then inspect the running system with tools and AI.
- Map the domain first Capture the command, event, read model, and team intent before the implementation spreads out. Open Studio
- Keep the slice together Put the command, handler, query, proxy, and UI for one behavior in one feature-shaped place. See vertical slices
- Resolve identity and tenant Authenticate once, resolve the tenant, enrich identity, and let services receive trusted context. Explore AuthProxy
- Store what happened Append facts through Chronicle's gRPC boundary and let projections turn them into read models on the storage backend you chose. Explore Chronicle
- Ship a typed React screen Generated TypeScript proxies and Components remove the hand-written API client and form plumbing. Browse Components
- Inspect the running system Use the CLI, Workbench, and AI tooling to browse events, replay projections, and diagnose observers. Use AI tooling
Why developers choose Cratis
Section titled “Why developers choose Cratis”Cratis is for teams that want the domain model to be the running system, not a diagram beside it. The big win is fit: Chronicle, Arc, Components, AuthProxy, Studio, the CLI, and the AI tooling are opinionated in the same direction, so codebases stay consistent, predictable, and easier for both developers and agents to work in.
Domain model, identity, tenant context, backend behavior, React screens, event history, and tools share one set of conventions.
Build behavior, not glueCommands, queries, read models, UI, and tooling share one model. You spend time on the slice, not the handoffs between products.
One contract to ReactC# commands and queries generate the TypeScript your frontend calls. Rename a property and the compiler finds every mismatch.
End-to-end foundationsAuthentication, tenant resolution, identity enrichment, authorization, and tenant isolation are part of the stack instead of every app’s custom plumbing.
Event sourcing by defaultChronicle records facts, projects read models, and keeps the history most information systems eventually need.
Open event backboneChronicle exposes a gRPC/protobuf boundary, has a first-class .NET client, and also ships TypeScript and Elixir clients/contracts.
Storage choiceRun Chronicle over MongoDB, PostgreSQL, Microsoft SQL Server, or SQLite without changing the event model.
Predictable for AIStrong conventions, analyzers, and .ai guidance give assistants the same rails developers use to build and operate the system.
Observable queries and typed components keep forms, tables, and dialogs current without reload code or duplicate client models.
Inspect it liveWorkbench, CLI, OpenTelemetry, recommendations, jobs, replay, and failed partitions show what Chronicle is doing.
One feature, one slice — typed end to end
Section titled “One feature, one slice — typed end to end”You write the behavior once in C#. Arc generates the TypeScript proxies. The React side can’t drift — rename a property in C#, rebuild, and the frontend stops compiling until you fix it.
// Command, event, and read model for one feature — in one file.[Command]public record RegisterAuthor(AuthorId Id, AuthorName Name){ public AuthorRegistered Handle() => new(Name); // returns the fact that happened}
[EventType]public record AuthorRegistered(AuthorName Name);
[ReadModel, FromEvent<AuthorRegistered>]public record Author([property: Key] AuthorId Id, AuthorName Name){ // This static method *is* the query — exposed over HTTP automatically. public static ISubject<IEnumerable<Author>> AllAuthors(IMongoCollection<Author> c) => c.Observe();}// Proxies are generated from the C# above — fully typed, always in sync.const [authors] = AllAuthors.use(); // live, updates as events arrive
<CommandDialog command={RegisterAuthor} title="Add author"> <InputTextField value={i => i.name} title="Name" /></CommandDialog>The platform pieces
Section titled “The platform pieces”The event sourcing engine — gRPC/protobuf boundary, .NET-first client, storage choice, Orleans runtime, and rich tooling over a durable event log.
ArcThe full-stack CQRS framework — commands, queries, and the generated proxies that keep React in sync.
ComponentsThe React component library — command dialogs, forms, and data tables wired to your proxies.
AuthProxyThe edge gateway — authentication, tenant resolution, identity enrichment, routing, and invites.
CLIA terminal window into a running store — inspect events, watch observers, and diagnose issues.
AI toolingSkills, rules, analyzers, CLI catalogs, and MCP support that let agents build and operate with the platform’s conventions.
Choose your starting point
Section titled “Choose your starting point”Cratis is modular. For a new information system, the default path is Chronicle + Arc + Components. For an existing system, a bounded CRUD slice, or a frontend/backend contract problem, you can adopt the pieces separately and still keep the same conventions.
| If you need… | Start here |
|---|---|
| A durable history of what happened | Chronicle |
| A language-neutral event-store boundary | Chronicle architecture |
| MongoDB, PostgreSQL, SQL Server, or SQLite storage | Chronicle storage |
| Typed commands, queries, and generated React proxies | Arc |
| Forms, dialogs, and data tables wired to Arc | Components |
| Authentication, tenant resolution, identity enrichment, and routing | AuthProxy |
| A way to inspect a running store | CLI |
| AI guidance for building and operating the stack | AI-native development |
| A guided adoption path from an existing app | Adopting Cratis |
| A role-based route through the docs | Learning paths |
| Runtime, package, and storage compatibility | Version compatibility |
| A production deployment checklist | Production readiness |
| Help choosing a path, debugging setup, or talking through a design | Community and help |
| Dedicated training, architecture review, or implementation help | Professional help |
| A place to suggest improvements or report confusing docs | Feedback and suggestions |
Coming from a familiar architecture? Start with the bridge that matches the shape of your code: CRUD / EF Core, MediatR, MVC, and Arc, or PrimeReact and Components.