@cratis/arc.vite weekly downloads statistics

Cratis Arc

Arc is an open-source (MIT) opinionated CQRS application framework for ASP.NET Core with commands, queries, validation, authorization, and TypeScript proxy generation. It works without event sourcing, with optional Chronicle integration.

Arc hosts application behavior, executes command and query pipelines, exposes recognized contracts over HTTP, and generates TypeScript clients for them. Its packages also cover observable queries, validation, identity and tenancy, React integration, current-state persistence, OpenAPI, analyzers, and testing. Chronicle event sourcing and Cratis Components are optional integrations.

Arc reflects a broader Cratis conviction: application plumbing should not be the hard part. Commands, queries, validation, and authorization are written as plain, idiomatic .NET code, designed to reduce friction and boilerplate in service of productivity, quality, and reliability. Arc is part of one deliberately simple ecosystem — AI-friendly by design, with free AI skills for building with the stack.

Start here

• Browse the Arc documentation • Read why Arc exists • Map familiar concepts when coming from MediatR and MVC • Try runnable samples — including Idea Loom and Library • Choose a documented application path • Understand Arc's independent boundary • Start an Arc host • Inspect packages and repository layout

What Arc owns

| Boundary | Arc provides |

| Hosting | ASP.NET Core hosting plus an Arc.Core HTTP host for workers, consoles, and custom services | | Commands | Model-bound and controller-based execution, validation, authorization, filters, scopes, typed results, and generated endpoints | | Queries | Model-bound and controller-based reads, paging and sorting, observable updates, WebSocket or Server-Sent Events transport, and query diagnostics | | Validation | Data annotations, FluentValidation, concept/command/query validators, generated client rules, and optional server preflight from React forms | | Identity and tenancy | Pluggable authentication, identity details, role-based authorization, and header, query, claim, subdomain, fixed, or development tenant resolution | | Generated contracts | TypeScript proxies, referenced types, validation metadata, identity details, incremental output cleanup, and package/type mapping | | Frontend packages | TypeScript command/query runtimes, React hooks and forms, dialogs, observable-query composition, and optional React/MVVM integration | | Persistence integration | MongoDB and Entity Framework Core current-state adapters plus optional Chronicle-backed event-sourced behavior | | Evaluation and tooling | OpenAPI, runtime introspection, analyzers, source generators, command scenarios, proxy-generation checks, Vite helpers, and ESLint rules |

Each row is a documented capability area, not a promise of compatibility with every package, host, provider, browser, or product version.

Choose a path

Arc documentation is organized around the job you need to complete:

• Execute commands — model-bound or controller-based changes, pipelines, validation, authorization, filters, and response handling. • Separate command decisions from inline side effects — preferred for already-decided work in model-bound commands, with optional best-effort compensation. Direct service calls remain supported; operations require neither Chronicle nor frontend recovery code. • Expose queries and observable results — request/response reads, paging, sorting, streaming updates, diagnostics, and generated clients. • Build the frontend — TypeScript runtimes, React hooks and forms, dialogs, identity, messaging, and optional MVVM packages. • Configure identity and access — authentication, identity details, authorization, roles, and frontend visibility boundaries. • Resolve tenants — request resolvers, scoped tenant context, and provider-specific database or namespace mapping. • Use current-state persistence — application services, MongoDB, or Entity Framework Core without requiring an event log. • Add Chronicle event sourcing — events, projections, reducers, aggregates, reactors, concurrency, and Chronicle-specific testing. • Inspect and verify the application boundary — introspection, OpenAPI, analyzers, generated metadata, and command scenarios.

The canonical Arc page remains the front door; product-owned documentation and source carry the detail.

Arc does not require event sourcing

Arc.Core does not depend on Chronicle. Commands and queries can use current-state persistence or application services without an event log. Choose the persistence and integrations that fit each application boundary.

The Chronicle integration is optional and supplies event-sourced behavior when configured. Arc retains its command, query, validation, authorization, and generated-contract boundary.

Chronicle is Cratis's storage-agnostic event-sourcing database and runtime — MIT licensed and free to use; see the Chronicle documentation for its own scope and setup.

Relationship to Components

Components is a React component library aligned with Arc application patterns. See the Components documentation for its packages and setup.

Applications may use Arc without Components and remain responsible for their own frontend, accessibility, browser, and design-system verification.

Start an Arc host

Arc's .NET packages embed this product-family README. The example below uses the Cratis.Arc package, Arc's ASP.NET Core integration; when viewing this README from a specialized package page, use that package's manifest and reference documentation for its own installation scope.

Use the .NET SDK declared by Arc's current global.json. Create an ASP.NET Core project and install the package:

Replace Program.cs and run the host:…

Description from the npm listing.