/// Application framework for .NET

Write the handler.
The build wires the rest.

One [Handler] class becomes a JSON-RPC method, a REST endpoint, and an MCP tool for AI agents — authorized, validated, and traced by a decorator pipeline that Roslyn source generators emit as ordinary C#. No reflection scanning, no startup discovery, no registration lists to drift.

Get started The philosophy

Modules/Clients/GetClient.csthe class you write

[Handler("clients.get")][HttpEndpoint("clients/{id}")][RequirePermission("clients", "read")]public sealed class GetClient(AppDbContext db)    : IHandler<GetClient.Query, Result<GetClient.Response>> {     public sealed record Query(Guid Id) : IQuery;    public sealed record Response(Guid Id, string Name);     public async ValueTask<Result<Response>> HandleAsync(        Query q, CancellationToken ct) {        var client = await db.Clients            .Where(c => c.Id == q.Id)            .Select(c => new Response(c.Id, c.Name))            .FirstOrDefaultAsync(ct);         return client is null            ? AppError.NotFound($"Client {q.Id} was not found.")            : client;    }}

what the build does with it → 01

.NET 10 · C# 14
NativeAOT paths
Zero runtime reflection
40+ focused packages
1,500+ tests
Apache-2.0

/// building with AI agents?The case for Elarion in an AI-first team — in business terms

01 / Generated outputEmitCompilerGeneratedFiles=true

Attributes in. Ordinary code out.

The generators run inside dotnet build and emit the wiring you would otherwise write and keep in sync by hand. It is code, not container magic — open it, read it, step through it.

DI registrations with the full decorator pipeline, composed in source.
Minimal-API route maps and the shared JSON-RPC + MCP operation registry.
A schema export that becomes a typed TypeScript client.

The DI registration — the decorator pipeline composed in source.

// <auto-generated/> — Elarion.Generators, abridged for readingpublic static IServiceCollection AddGetClient(this IServiceCollection services) {    services.AddScoped<GetClient>();    services.AddScoped<IHandler<GetClient.Query, Result<GetClient.Response>>>(BuildPipeline);    return services;} private static IHandler<GetClient.Query, Result<GetClient.Response>> BuildPipeline(    IServiceProvider sp) {    IHandler<GetClient.Query, Result<GetClient.Response>> handler =        sp.GetRequiredService<GetClient>();    handler = new AuthorizationDecorator<GetClient.Query, Result<GetClient.Response>>(handler, …);    handler = new ObservabilityDecorator<GetClient.Query, Result<GetClient.Response>>(handler, …);    return handler;}

a.Deterministic startup

The host calls generated registrations. Nothing scans assemblies at run time, so boot behavior is fixed at build time.

b.NativeAOT-ready paths

Emitted code is concrete and statically typed, and JSON serialization is source-generated — supported AOT paths avoid runtime discovery.

c.Reviewable like your own code

Flip EmitCompilerGeneratedFiles and the wiring shows up in code review as plain C# diffs.

02 / Capability index30+ capabilities · 40+ packages

Everything an application needs. Nothing you didn't reference.

Each capability is a focused package over seams in Elarion.Abstractions. The core depends on Microsoft.Extensions abstractions and nothing else — Polly, HybridCache, and OpenFeature enter your build the day a handler asks for them, not before.

Transports & contracts

JSON-RPC 2.0One /rpc endpoint with envelopes, batching, telemetry, and build-time schema export.[Handler]REST endpointsMinimal-API routes with verb inference and RFC 7807 ProblemDetails failures.[HttpEndpoint]MCP toolsThe same handlers served to AI agents over Streamable HTTP — one registry, no drift.HandlerTransports.Mcp TypeScript clientMethod contracts, Zod schemas, and a portable fetch client generated from the schema.rpc-client.ts

Security

AuthorizationPermissions, roles, claims, and named policies enforced in the pipeline — on every transport.[RequirePermission]Permission catalogEvery declared permission aggregated into a typed, queryable catalog at compile time.IPermissionCatalog Data-level filtersOwner, tenant, and grant rules compiled into EF Core predicates — rows filter in SQL, not memory.[ResourceFilter<T>]IdentityASP.NET Core Identity composed onto your plain DbContext; any OIDC/JWT provider works too.[GenerateElarionIdentity]

Data & persistence

EF Core wiringDbSets and configuration application emitted from entity configurations — one source of truth.[GenerateDbSets]PaginationKeyset cursors with provider-aware row-value seeks, plus offset paging over one SortMap.[Keyset<T>]Bulk insertsNon-tracking inserts over PostgreSQL binary COPY, shaped for high-rate write paths.ExecuteInsertAsync NativeAOT SQLGenerated row mappers, safe interpolation, and ordered SQL migrations without EF Core.[SqlRecord]Blob storageStreaming-first store with direct and resumable (tus) uploads and a pending → commit lifecycle.IBlobStore TransactionsOne unit-of-work boundary — business writes, events, and idempotency keys commit together.IUnitOfWork

Reliability & messaging

Two-plane eventsDomain events commit with the command; integration events deliver after the transaction commits.[ConsumeEvent]Transactional outboxAt-least-once delivery, recorded in the same transaction as your data — or in-memory for dev.Elarion.Messaging.Outbox IdempotencyA database row fences duplicates; a retried command replays its stored result instead of re-running.[Idempotent]ResilienceNamed retry/timeout pipelines attach as decorators; the policy catalog stays dependency-light.[Resilient]

Realtime & coordination

Client eventsAt-most-once hints tell browsers to re-query; reconnect greetings make views converge.IClientEvent Ordered streamsSequenced hot broadcasts with bounded replay, visible gaps, and resumable SSE.StreamHub<T>Client connectionsBidirectional WebSocket and TCP links for devices, interactive input, and server-to-client RPC.IClientConnection Device identitySingle-use pairing, key rotation, and constant-time HMAC handshakes for device links.HmacChallengeVerifier ActorsMailbox-serialized live state with generated typed facades; use only when a row is not the answer.[Actor]Role leasesElect one instance for a coarse role and proxy holder-owned HTTP routes when needed.IRoleLease Data-rate shapingBatch loss-tolerant writes and conflate latest-wins values before they hit storage or the UI.WriteBehindBuffer<T>

Operations

CachingTwo-tier HybridCache with a PostgreSQL L2 — reuse the database you already run, skip Redis.[Cacheable]Feature flagsGated handlers return 404 while disabled; variants swap service implementations per request.[FeatureGate]Runtime settingsGlobal and per-user settings with optimistic concurrency and live IConfiguration reload.ISettingsManager SchedulingSource-generated jobs with overlap and misfire policy; ${setting} recurrence reschedules live.[ScheduledJob]TelemetryOpenTelemetry-compatible traces and metrics from every transport and the scheduler — on by default.ActivitySource Audit trailExplicit durable action records with outcomes, resource context, trace correlation, and optional diffs.[Auditable]

The full package reference

03 / Diagnostics100+ compile-time checks

Wrong wiring doesn't ship.

What the generators wire, they also validate — every mistake becomes a precise diagnostic with a fix direction. Production never finds out.

A reach into another module is flagged as you type (ELMOD002).
A route with no inferable verb fails the build, not the demo.
An authorization gate that can't fail closed is an error, not a hope.

Reflection scanningElarion

✗Wiring discovered by scanning assemblies at startup✓Wiring emitted as inspectable C# at build time

✗A missing registration surfaces as a runtime exception✓Missing wiring is a compile error, caught in CI

✗Reflection undermines trimming and native AOT✓Trim- and AOT-friendly by construction

✗A parallel registration list drifts from the code✓Intent declared on the type — one source of truth

Every diagnostic is documented, from ELRPC001 to ELMOD002 — see the full list.

dotnet buildexit code 1

$ dotnet build Billing.Application → bin/Release/net10.0/Billing.Application.dll Modules/Sales/CreateOrder.cs(12,34): warning ELMOD002: Type 'Invoice' belongs to module 'Billing'; module 'Sales' must not depend on another module's internals — reach it through a [ModuleContract], or move the shared type out of the module Modules/Billing/ExportInvoices.cs(8,14): error ELAUTH001: Handler 'ExportInvoices' declares an authorization requirement but its response type 'string' does not implement IResultFailureFactory<T>, so the authorization check cannot short-circuit; return Result<T> or Result Build FAILED. 1 Warning(s) 1 Error(s) $

04 / Field reportone production migration · real numbers

The first migration deleted 16,223 lines.

Elarion wasn't designed on a whiteboard — it was extracted from a production application that had grown its own foundation: handler pipeline, transports, wiring, caching, the lot. The pull request that moved that application onto the released packages added 391 lines and removed 16,223. The same application came out the other side, minus its plumbing.

git diff --shortstat home-grown..elarionone pull request

insertions(+)+391

deletions(-)−16,223

net −15,832 lines · 41 deleted for every line added

a.What the 16,223 were

Bespoke infrastructure — dispatch, registration, caching, retries, auth glue. Code every product rewrites and no product differentiates itself by.

b.What the 391 are

Package references, attributes on the handlers that already existed, and a few registration calls — the declarations the build expands into wiring.

c.Why net −15,832 matters

Every deleted line is one your team no longer reviews, tests, or patches — and one your AI assistants never read, or bill you for, again.

///why it's built this wayThe philosophy, for engineers — one maxim, the pipeline, the batteries

05 / Start~5 minutes

A working handler in three steps.

Step 1 — add the packages

The generators ride along as analyzers — nothing extra to install.

your project3 files · 1 project

MyApp/

├─ MyApp.csproj← step 1

├─ Program.cs← step 3

└─ SystemFeature.cs← step 2

Step 2 — declare one feature

SystemFeature.cs

using System.Text.Json.Serialization;using System.Text.Json.Serialization.Metadata;using Elarion.Abstractions;using Elarion.Abstractions.Modules;using Elarion.AspNetCore; [assembly: UseElarion][assembly: GenerateModuleBootstrapper] namespace MyApp.System; [AppModule("System", Kind = AppModuleKind.Core)]public static partial class SystemModule {    public static IJsonTypeInfoResolver GetJsonTypeInfoResolver() =>        SystemJsonContext.Default;} [Handler("system.ping")][HttpEndpoint("ping")]public sealed class Ping : IHandler<Ping.Query, Result<Ping.Response>> {    public sealed record Query : IQuery;    public sealed record Response(string Message);     public ValueTask<Result<Response>> HandleAsync(        Query query, CancellationToken ct) =>        ValueTask.FromResult<Result<Response>>(new Response("pong"));} [JsonSerializable(typeof(Ping.Query))][JsonSerializable(typeof(Ping.Response))]public sealed partial class SystemJsonContext : JsonSerializerContext;

The build now emits

✓DI registration + observability pipeline
✓GET /ping — minimal API
✓system.ping — operation metadata
✓source-generated JSON metadata

Step 3 — wire the host

Program.csthe complete host

using Elarion.AspNetCore;using MyApp; var builder = WebApplication.CreateSlimBuilder(args); builder.Services.AddElarion(builder.Configuration);builder.Services.AddElarionHttpJson(); var app = builder.Build(); app.MapElarionEndpoints(app.Configuration); app.Run();

This sample has no hidden database or undeclared dependency: build it and call GET /ping. The quickstart adds JSON-RPC, while the MCP guide exposes the same operation registry to AI agents; the handler and its policy stay unchanged.

Open the quickstart Follow the full tutorial GitHub

The tutorial builds a billing app end to end — modules, authorization, events, and a typed React client.

Write the handler.The build wires the rest.