Cephalon Engine

One engine. Every shape of serious .NET workloads

Ship modular monoliths, microservices, event-driven services, and edge workloads from one composition model. Built on .NET 10 for teams that care about reliability, velocity, and long-term maintainability.

Cephalon Engine .NET

Get started in 5 minutes Explore architecture

Install dotnet tool install -g Cephalon.Cli --prerelease

.NET 10 LTS MIT licensed 10+ hosts 40+ companion packages

Program.cs

// Compose a modular host in 6 lines
using Cephalon.AspNetCore;
using Cephalon.Engine;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Services
    .AddCephalonAspNetCore()
    .AddModulesFromAssemblies(typeof(Program).Assembly)
    .AddObservability(options => options.UseOpenTelemetry())
    .AddData(options => options.UseEntityFramework())
    .Build(builder);

app.MapCephalon();
app.MapHealthChecks("/health");

app.Run();

.NET 10 LTS baseline

40+ Companion packages

7 Host shapes supported

M0–M4 Explicit maturity labels

Deterministic compositionOperational safety railsVersioned contractsScale without rewritesPolicy-driven defaultsCloud-ready telemetry

Why Cephalon Engine

Engineered for teams that outgrow starter templates

Cephalon keeps the core intentionally small, then layers capability through optional companion packages. Start with one host, evolve into multiple workloads, and keep a single architectural language from prototype to production.

Module-first composition

Modules declare capabilities, services, lifecycle hooks, and transport surfaces. The engine resolves them deterministically with a typed manifest.

Multiple app models

Pick a composition style, deployment topology, feature organization, and transport per app. No rewrite when shapes change.

Honest maturity labels

Every package ships with an M0–M4 label so adopters know exactly what is taxonomy-only, narrow, or adoption-ready.

Transport adapters built-in

REST, JSON-RPC, gRPC, GraphQL, SSE, and WebSocket. Each module chooses what to expose and the engine maps everything consistently.

OpenTelemetry-native observability

Logs, metrics, traces, and dependency-health probes ship as first-party companion packages with provider adapters for every major cloud.

Data, identity, multi-tenancy

Optional companion packages for EF Core, identity, multi-tenancy governance, audit, and Sfid identifiers with runtime-neutral defaults.

Eventing first-class

Wolverine adapter is the current managed dispatch path. Brokers, scheduled delivery, DLQ replay, and process managers are first-party.

Deploy anywhere

Generated apps ship with Windows Service, IIS, Azure App Service, Azure Container Apps, Kubernetes, Linux systemd, and Docker scripts on day one.

Test scaffolding included

Generated test projects come with composition smoke tests and per-feature behavior specifications so teams skip the boilerplate.

Quick paths

Pick a path that matches the day-one decision

I’m new here

Quickstart

Install the CLI, scaffold an app, and run the generated host in under five minutes.

Start the quickstart I’m evaluating

Concepts and architecture

Read the layered model, the app-model dimensions, and the engine composition rules before adopting.

Read the concepts I’m building

Tutorial library

End-to-end tutorials for modular monoliths, microservices, multi-tenant SaaS, gRPC services, and observability stacks.

Browse tutorials I’m migrating

Migration playbooks

Move from plain ASP.NET Core or split a legacy monolith. Each path comes with step-by-step diffs and risk callouts.

Open the playbooks I’m operating

Operations and hardening

Runtime failure policy, observability conventions, dependency health, benchmarking, and deployment runbooks.

Open operations I’m contributing

Contributor handbook

Engineering standards, module authoring rules, package lifecycle, release process, and how to extend the engine.

Read the handbook

Composition that fits on one screen

A Cephalon host is just a builder, a set of modules, and a runtime. The same engine wires REST, gRPC, GraphQL, eventing, observability, and data, driven by configuration instead of sprawling Program.cs files.

ASP.NET Core host Program.cs Generic-host worker Program.cs Module declaration OrdersModule.cs appsettings.json appsettings.json

using Cephalon.AspNetCore;
using Cephalon.Engine;

var builder = WebApplication.CreateBuilder(args);

var app = builder.Services
  .AddCephalonAspNetCore()
  .AddModulesFromAssemblies(typeof(Program).Assembly)
  .AddObservability(options => options.UseOpenTelemetry())
  .AddData(options => options.UseEntityFramework())
  .Build(builder);

app.MapCephalon();
app.MapHealthChecks("/health");

app.Run();

using Cephalon.Engine;
using Cephalon.Worker;
using Microsoft.Extensions.Hosting;

var builder = Host.CreateApplicationBuilder(args);

var runtime = builder.Services
  .AddCephalonWorker()
  .AddModulesFromAssemblies(typeof(Program).Assembly)
  .AddEventing(options => options.UseWolverine())
  .Build(builder);

await runtime.RunAsync();

using Cephalon.Abstractions.Modules;
using Cephalon.AspNetCore.Behaviors;

public sealed class OrdersModule : RestBehaviorModuleBase
{
  public override ModuleDescriptor Describe() => new(
      name: "Orders",
      version: "1.0.0",
      capabilities: [Capability.Data, Capability.Eventing]);

  protected override void ConfigureRestBehaviors(IRestBehaviorBuilder builder)
  {
      builder.MapProfile<CreateOrderBehavior>();
      builder.MapProfile<ListOrdersBehavior>();
  }
}

{
"Engine": {
  "Id": "acme-store",
  "Data": { "IdStrategy": "Sfid", "Provider": "Postgres" },
  "Audit": { "Enabled": true },
  "Identity": { "Enabled": false },
  "Tenancy": { "Enabled": false },
  "Messaging": { "Enabled": false },
  "Transports": [ "RestApi" ]
}
}

Built for production from day one

A complete platform, not a starter kit

Data the way you want it

Runtime-neutral data abstractions with optional EF Core, MongoDB, Cassandra, Postgres, SQL Server, Oracle, Redis, MySQL, Elasticsearch, ClickHouse, Neo4j, NATS, Qdrant adapters.

Identity & multi-tenancy ready

Host-agnostic identity and authorization, ASP.NET Core adapters, tenant resolution, ambient tenant context, durable membership/invitation governance, declared domain ownership, and approval/remediation workflows.

Cloud-native observability

OTLP exporters and managed defaults for Alibaba Cloud, AWS, Azure Monitor, DigitalOcean, GCP, Grafana Cloud, Huawei Cloud, Kubernetes, New Relic, OpenShift, Oracle Cloud, Serilog, and Tanzu.

Operational hardening built-in

Runtime failure policy, dependency-health probes across 18 backends, generated runbooks, container image publishing, BenchmarkDotNet hot-path coverage, and conformance matrices.

For the long term

Design choices that age well

Explicit contracts

Every public surface ships with a runtime contract entry, conformance matrix row, and maturity label. No silent breaks.

Stable shipping floor

.NET 10 LTS is the shipping baseline. The .NET 11 readiness lane is tracked publicly with assessment-only status.

Multi-version docs

Every released version ships its own snapshot — guides, components, and API reference. Switch versions from the header.

💡

Preview status. CephalonEngine is currently on the 0.1.0-preview track. Packages below M4 may evolve additively while we drive the public surface toward adoption-ready. Stability commitments are tracked in the maturity audit and the roadmap.

Start where you are

Choose your next move

QuickstartInstall the CLI, run cephalon doctor, scaffold an app, and deploy.TutorialsBuild end-to-end examples for monolith, microservices, and multi-tenant SaaS.TechnologyBrowse the companion package catalog by domain, runtime, and deployment concern.MigrationFollow structured playbooks for onboarding and version-to-version upgrades.ReferenceInspect runtime contracts, configuration schema, CLI surfaces, and API docs.ContributingAdopt engineering standards, package lifecycle rules, and release process details.AboutTrack roadmap, release notes, governance details, FAQ, and project license.