The stack
One cast. One accountable lifecycle.
Cratis is the open application and event-lifecycle stack for accountable .NET business systems. It is not a catalog of repositories. It is one path through the life of a long-lived system: design together, build on an open runtime, operate from durable facts, and improve with evidence. One ecosystem, kept deliberately simple.
Capability map
Know which piece does the job.
One ecosystem, with focused products you can adopt separately. Released means packages or images are published, not a promise of feature parity across languages; the support matrix has the details.
| Product | What it does | Maturity | Go deeper |
|---|---|---|---|
| Chronicle | Keeps the event history and turns it into read models and reactions through a language-neutral gRPC boundary. | Released | Chronicle docs |
| Arc | Connects backend commands and queries to generated TypeScript clients and React hooks without requiring event sourcing. | Released; TypeScript backend in source preview | Backend · Frontend |
| Components | Builds React forms, command dialogs and query-backed tables on Arc's generated proxies. | Released | Components docs |
| Fundamentals | Provides reusable concepts, serialization and other shared building blocks beneath the stack. | Released | Fundamentals docs |
| CLI | Inspects and diagnoses Chronicle events, observers and failed processing from the terminal. | Released | CLI docs |
| Studio | Gives teams a shared canvas for designing commands, events and read models as Screenplay models. | Preview · paid product | Studio docs · The offer |
| Screenplay | Records desired business behavior in a portable declarative .play model. |
Experimental | Screenplay docs |
| Prologue | Observes selected signals from an existing system and proposes an event model for your review. | Experimental | Prologue docs |
Chronicle clients: .NET · TypeScript · Kotlin / Java · Elixir · Go (experimental) · Python (pre-alpha, not published). Client coverage differs; start with Chronicle in your language. The open tools are MIT-licensed; Studio is a separate paid product.
Start small: Your first five minutes with Chronicle → Follow one fact through an event, a projection and a reaction.
The lifecycle
Design → Build → Operate → Improve.
Each surface has a clear job. Together they preserve intent, behavior and history as the system changes over years.
Agree on the business
Model commands, facts and views together, then explore the model as a live preview.
Cratis Studio
Carry one typed contract
C# commands and queries become HTTP APIs, TypeScript proxies and React continuity.
Cratis Build
Work from the event record
Use the documented inspection and operational workflows available in each current tool; coverage varies by tool and version.
Workbench · CLI · MCP
Feed evidence back
Use runtime history and specifications to explain state and shape the next change.
Chronicle · Specifications
Nothing in that sequence is a second architecture. It is one model seen at the point where the team needs it.
Cratis Build
The open runtime and operating foundation.
Chronicle, Arc, Components and the operating tools are one open offer. Package boundaries stay useful to developers; customers do not have to decode the repository map.
Owns the event lifecycle: contract facts, append them in order, evolve schemas, derive read models, react to change, replay when understanding changes, and inspect or repair failed processing. The durable record remains the source from which current state can be explained.
And it runs on the databases companies already operate, so keeping the full history fits into your existing operation — not the other way around.
- gRPC / protobuf boundary
- MongoDB
- PostgreSQL
- SQL Server
- SQLite
- Orleans runtime
- Replay & recovery
- Namespaces for tenancy
Turns behavior into a typed application. A C# command becomes an HTTP endpoint and a generated TypeScript proxy — so many backend contract changes surface as TypeScript compile errors instead of silent mismatches. Identity, authorization and tenancy are part of the framework, not per-app boilerplate.
- Commands & queries
- Proxy generation
- Roslyn analyzers
- Tenancy
- Identity & authorization
- Works without event sourcing
Renders Arc's generated proxies as forms, dialogs and data tables. Generated contracts remove the hand-written API client; observable queries keep the screen current without reload code.
- Command dialogs
- Data tables
- Schema editors
- Observable queries
Authenticates at the edge, resolves the tenant, enriches identity, and forwards trusted context to configured HTTP services according to AuthProxy's current routing and integration documentation.
- Authentication
- Tenant resolution
- Identity enrichment
- Routing & invites
Workbench, the CLI, and Chronicle MCP provide public operating surfaces with different current coverage. Workbench offers browser inspection and interaction; the CLI documents event, observer, failed-partition, replay, retry, and job workflows; Chronicle MCP documents event-store, event, observer, recommendation, job, and identity tools. Treat replay and other operational actions as writes, and keep business changes on domain command and event paths.
- Workbench
- CLI
- Chronicle MCP
- Narrator
- Lens
- Synopsis
Separate offers
Design and expertise without changing the Build boundary.
Studio and Assurance work alongside Cratis Build. Neither is part of Build, and neither is required as permission to run or repair Build in your own environment.
Studio is the separate paid design product. Teams model commands, events, and read models together, and Stage can perform supported behavior in a sandbox. Stage remains experimental. Screenplay provides the portable model. Prologue is an emerging brownfield aid; verify its current scope before planning an adoption around it.
Studio is in Preview and public sign-up is not open yet. The Studio page describes export and retention.
Studio →Assurance covers support, reviews, first slices, production readiness, and workshops with scope, availability, and commitments defined by the signed agreement. It does not gate access to Build or its operating tools.
Cratis Assurance →Adoption
Take one piece, or take all of it.
Each product has a focused role and can be adopted selectively. The dependency only runs one way — Arc can sit on top of Chronicle, but Chronicle never knows Arc exists.
| You want | Reach for | Event sourcing? |
|---|---|---|
| History as the source of truth through a documented client | Chronicle on its own | Yes |
| A typed full-stack app over a traditional database | Arc + Components over MongoDB or EF Core | Not required |
| Authentication, tenancy and routing at the edge | AuthProxy in front of your services | Optional |
| A typed full-stack app and a full event history | Arc + Chronicle + Components | Yes |
| A product-grade SaaS shape, end to end | AuthProxy + Arc + Components + Chronicle + CLI | Default |
The last row is where the stack is at its best, and it's the default for a new information system. The CLI and other operating tools are optional, not prerequisites for using Chronicle or Arc. Coming from an existing one? Adopting Cratis walks through taking one piece at a time.
Documented boundaries, with explicit coverage
Chronicle exposes a gRPC and protobuf boundary. Client libraries and storage providers have different maturity and coverage; .NET is the primary experience. Check each repository's license and the current support matrix before choosing a boundary, and the capability map for each product's scope and maturity.
On purpose, and only where it pays
Conventions over configuration, vertical slices over layers, facts over current state. The opinions are what make codebases consistent — and consistency is what makes onboarding fast and AI assistance less speculative. They are also how we take friction out of the day-to-day work — the opinions exist to remove decisions, not to add ceremony.
Evaluate the stack
Start here.
- Install. Check the prerequisites and scaffold a local application with the template getting-started guide.
- Model and build one slice. Follow Build a full app from a command through its event and projection to the screen.
- Run it. Use the local startup instructions to start Chronicle, the backend and the frontend, then register a name and inspect its event in Workbench.