Overview
What is Anarchy I/O Toolkit?
The Anarchy I/O Toolkit is a .NET developer platform: an integrated ecosystem for building maintainable .NET applications (REST and GraphQL APIs, Blazor WebApps, AWS Lambda jobs and EC2 workers) through consistent architecture, reusable infrastructure and automated development workflows.
Provide the foundation. Never dictate the destination. The toolkit ships plumbing, not a framework: your domain, your architecture decisions and your vendors stay yours, and no part of the platform requires adopting the rest.
The three pillars
| Pillar | What it provides | Start with |
|---|---|---|
| Architecture | How applications are structured and how dependencies are governed: the layers Core < Infrastructure < Configuration < Hosting < Web < Automation in the toolkit, DI modules as the unit of composition, and conventions for async code, exceptions, enums, endpoints and tests. |
Layered Architecture, Guides |
| Infrastructure | Reusable application capabilities, published as independent NuGet packages: core abstractions, persistence (PostgreSQL, Oracle, MySQL), AWS SNS/SQS messaging (the only supplied transport today), telemetry, configuration and secrets, hosting for jobs and workers, REST/GraphQL/Blazor pipelines, and testing kits. | Package Catalog |
| Build Ecosystem | Tools and workflows for developing and delivering applications: the Automation.Build build components (compile, lint, test, layering check, dependency map, packaging, versioning, releases, Docker) and the anarchy-toolkit CLI (solution bootstrap and scaffolding), with a distributed Makefile and scripts. Powered by Fallout Build. |
Getting Started, Anarchy Automation Builds |
How the pillars work together
The pillars are conceptual product areas, not layers: none of them is a runtime dependency of another. Architecture defines where code goes; Infrastructure packages are organized by those same layers and wired through the same DI modules; the Build Ecosystem scaffolds solutions with that structure and enforces it (make check_layering) while it builds, tests, packs and releases them. The Build Ecosystem runs at development and delivery time only and is never part of the deployed application.
Conceptual platform diagram (not the project-reference graph, which follows below):
flowchart LR
subgraph Architecture["<b>Architecture</b>"]
A1["Layering · contracts"]
A2["Conventions · composition"]
end
subgraph Infrastructure["<b>Infrastructure</b>"]
I1["Core abstractions · persistence · messaging"]
I2["Telemetry · configuration · hosting"]
I3["Web · testing kits"]
end
subgraph BuildEcosystem["<b>Build Ecosystem</b> (development time)"]
B1["Automation · CLI · scaffolding"]
B2["Validation · packaging · versioning · releases"]
end
Apps["<b>.NET applications</b><br/>APIs · workers · jobs · web apps"]
Architecture -->|structures| Apps
Infrastructure -->|runs inside| Apps
BuildEcosystem -.->|builds, validates, ships| Apps
Independent adoption
| You have | Start with | Page |
|---|---|---|
| An empty folder | The anarchy-toolkit CLI tool: a layered solution with its build, plus APIs, jobs and UIs. |
New solution with the CLI |
| An existing repository | Anarchy automation components: compile, lint, test, layering, packaging and releases. | Adding Anarchy automation |
| An existing application | Individual packages, wired through their DI modules. | Using the packages |
Platform architecture and dependency model
Every project under src/ is one package, versioned and published on its own to NuGet.org. Its package ID, assembly name and root namespace are all Anarchy.Toolkit.<project name>, and its prefix is its layer. Dependencies only point down the layers, which make check_layering enforces:
flowchart TB
Build["<b>Automation</b><br/>build components · CLI tool"]
Web["<b>Web</b><br/>REST API · GraphQL · Blazor UI"]
Hosting["<b>Hosting</b><br/>Startups · jobs · workers"]
Configuration["<b>Configuration</b><br/>Settings · secrets · telemetry bootstrap"]
Infrastructure["<b>Infrastructure</b><br/>Databases · AWS messaging · HTTP · correlation · Serilog"]
Core["<b>Core</b><br/>Abstractions · events · health · telemetry"]
Testing["<b>Testing kits</b><br/>Fixtures · DB/AWS/Web helpers"]
Build --> Web --> Hosting --> Configuration --> Infrastructure --> Core
Testing -.-> Web
Testing -.-> Infrastructure
The Package Catalog lists every package by layer, and the Layered Architecture guide explains the rule, including an interactive map of the project references.
Design principles
- Pluggable. Packages with concrete services register them through an
IDependencyInjectionModuleor anIServiceCollectionextension, so an application wires each one in a single call. Modules never assume a configuration section: options always come from the application. - Domain-free. Generic code takes strings and generic parameters instead of domain enums. Domain code (repositories, clients, event payloads, message destinations, UI environments) stays in your applications.
- Vendor-neutral. Company-specific conventions plug in through extension points: your own logging providers, metric recorder and OTLP exporter registered in DI for logs and metrics, options and constructor parameters, and
ConfigureAppConfigurationhooks for configuration sources. - Standalone. Every dependency restores from nuget.org; test-only libraries such as AwesomeAssertions are confined to the
Testing.*kits.
Values and Decisions lists every value and the architectural decisions behind the platform.
Samples
The samples are runnable applications (a REST API, a Lambda job, a worker, a WebApp, a mock server and their tests) that together show the three pillars composed: each is laid out by the architecture, built on the infrastructure packages and validated by the Anarchy build.
Learn more
- Guides: how the platform fits together, walkthroughs for new and existing solutions, onboarding recipes and the platform features.
- Conventions: recommendations for applications on the platform, and how to opt out of each.
- Values and Decisions: why the platform is built the way it is.
- Package Catalog and NuGet.org: every package, by layer.
- API reference: the generated reference for every public type.