Attribute-driven helpers for registering services, hosted services, typed HTTP clients, and options in Microsoft.Extensions.DependencyInjection.
A build-time-only migration aid: converts AutoMapper Profiles into Mapwright mappers. An analyzer spots each class deriving from AutoMapper.Profile and offers a code fix that writes the equivalent [Mapper] partial class beside it, flagging every construct it cannot translate rather than dropping it. Install it for the migration, delete it afterwards. It takes no dependency on AutoMapper itself.
.NET tool for enforcing configuration-driven architectural seams without modifying target projects.
Provides an analyser to generate code for dependency injection registrtion.
Compile-time architecture/dependency-rule enforcement for .NET using Roslyn source generators. Declare [assembly: ForbidDependency("MyApp.UI", "MyApp.DataAccess")] and get a build warning/error the moment a forbidden reference is introduced — no separate CI step, no NDepend license required.
ModrinthSharp is a .NET 8 library for accessing the Modrinth API in C#. It provides easy-to-use methods for searching, retrieving, and analyzing Modrinth projects, versions, users, teams, dependencies, and files.
Roslyn analyzer for validating declared dependency contracts on .NET types.
Roslyn analyzer for enforcing configuration-driven architectural seams.
A struct-based, allocation-free-on-success Result type for .NET with a safe default, one aggregating Error, and complete Task and ValueTask railway extensions. No dependencies outside the BCL.
A struct-based, allocation-free Maybe type for .NET with a safe default (none), explicit absence instead of null, and complete Task and ValueTask railway extensions. No dependencies outside the BCL.
Build-time IL weaver for NumSharp's [NDScoped]/[NDScopedAsync] deterministic memory reclamation. Installing this package wires a post-compile step into your project's build: every method you mark [NDScoped] (synchronous) or [NDScopedAsync] (async/Task) is rewritten to open an NDScope, so the NDArray temporaries it drops are returned to NumSharp's buffer pool the moment the method exits instead of waiting on the finalizer. Ships as MSBuild targets + a tool only — it never becomes a runtime dependency of your project (`dotnet add package` installs it with PrivateAssets="all" automatically). The companion Roslyn analyzer (which reports a wrong or unsupported [NDScoped] target as a compile error and nudges on leaked NDArray temporaries) ships inside the NumSharp package itself, so it is already active in any project that can use the attributes.
Core abstractions for NullShield — a compile-time NullReferenceException mitigation library powered by Roslyn Source Generators. Zero dependencies. Zero runtime overhead.
A powerful, privacy-first local intelligence framework for .NET applications. Analyze user behavior, generate insights, and discover patterns entirely offline without external dependencies.
Core abstractions for NullShield — a compile-time NullReferenceException mitigation library powered by Roslyn Source Generators. Zero dependencies. Zero runtime overhead.
Compiler-hosted architecture dependency diagnostics for C#.
Opt-in compile-time diagnostics for non-deterministic APIs (ambient clock, process randomness, Guid.NewGuid, randomized hashing, environment identity, scheduling) inside [Deterministic] scopes, with concrete SsalKit alternatives named in every message. Zero dependencies.
Analyzer that warns that you have have dependency free Tasks which are currently being run sequentially instead of in parallel
Use Maxen.DI as the container behind Microsoft.Extensions.DependencyInjection and the Generic Host.
Maxen.DI - a highly extensible dependency injection framework: pluggable lifetimes, middleware pipeline, decorators, interceptors, child containers, validation and a source generator.
Roslyn analyzer to add attribute based dependency injection configuration.
Roslyn analyzers that enforce the shape of types based on what they inherit or implement, configured in .editorconfig: for example, every IEndpoint implementation must be internal and sealed, every request handler must have its own IFooHandler interface, entities must not expose public setters or mutable collections or hold other aggregate roots, value objects must be immutable, compare by value and be created through factory methods, and EF Core configurations must live in a Database.Configurations namespace. Violations show up in the IDE while you type, and fail the build with TreatWarningsAsErrors, instead of waiting for an architecture test to run. Most rules have a code fix, offered only when applying it can't break the build.
A small static IoC container with [Dependency] field injection, plus Roslyn analyzers that catch common misuse.
Command line tool for Maxen.DI: prints the dependency graph of the modules in an assembly and checks it for problems.
One-line Maxen.DI setup for ASP.NET Core minimal APIs and MVC, plus helpers to reach the request's Maxen scope.
Eigenverft.Distributed.Drydock is a specialized command-line .NET tool designed to enhance solution and project file management. It provides advanced capabilities for reading and analyzing .NET solution (.sln) and project (.csproj) files, with features including: - Retrieving and analyzing project properties from .csproj files - Extracting project paths and dependencies from solution files - Smart project sorting based on test/non-test project types - Support for MSBuild property analysis with inner/outer element scoping - Built-in logging and error handling for reliable automation Ideal for build automation, CI/CD pipelines, and project management tasks that require deep .NET project structure analysis.
Rulebearing's architecture rules (rulebearing.yaml) as Roslyn diagnostics: a forbidden dependency or a broken element rule fails dotnet build with the line and the rule's fix.
Architecture rules for .NET, enforced at compile time by Roslyn analyzers.
A zero-dependency, deterministic toolkit of classic (non-neural, CPU-only) pattern-discovery and data-mining algorithms for .NET: frequent itemsets and association rules, sequential and episode mining, process mining, clustering, anomaly detection, graph mining, causal-structure tests, time-series motifs, and more. Speak in your own labels through the fluent on-ramp; the integer encoding the analyzers require is handled for you. Every algorithm is validated against planted-truth datasets.
Optional Roslyn source generator for OttoMapper that compiles convention-based maps at compile time. Reference as an analyzer (PrivateAssets=all) alongside OttoMapper.Mapping. Without this package, OttoMapper uses its runtime expression-tree path unchanged.
Know what breaks before you migrate. UpgradeMap scans a .NET solution and reports the migration blockers (WebForms, WCF, BinaryFormatter, COM interop, AppDomain/Remoting — with file and line), NuGet package verdicts against modern .NET, a dependency-ordered upgrade sequence, and evidence-backed effort bands. Runs locally; your source code never leaves the machine. Emits a console summary, a self-contained HTML report, or JSON for CI.
Production-grade `dotnet new` templates for a .NET 10 Web API on Clean Architecture, DDD and CQRS: Domain, Application, Infrastructure and Api projects with the dependency rule enforced by architecture tests, the source-generated Zenvoy mediator (no reflection, no assembly scanning) with a five-stage behaviour pipeline, transactional in-process domain events as Zenvoy notifications, Zenvoy.Results struct Result/Error with its analyzer, mapped to localized RFC 9457 ProblemDetails, JWT auth with refresh tokens, device sessions and permission-based RBAC, PostgreSQL via EF Core, Redis cache, S3/MinIO storage, SignalR, Quartz, Serilog and OpenTelemetry — plus unit, integration and NetArchTest architecture tests.
Roslyn analyzers and code fixes for .NET service mistakes that compile fine and fail at runtime: Dapper SQL/parameter mismatches and misuse, async/cancellation correctness, Serilog template pitfalls, configuration-key typos, controller hygiene and missing auth attributes, captive DI dependencies, mixed JSON serializer attributes, and DateTime.Now beside an injected clock.
The IronKernel parser, analyzer, compiler, REPL, and session protocol as a library, with the standard library (kernel.ikr, promises.ikr) copied beside the host. Depends on IronKernel.Runtime. Install IronKernel.Tool for the `ik` command.
Generate an interface from a class, and have the class implement it, with a single attribute.
Compile-time unload-safety guidance for Modularis plugins.
Roslyn analyzers that catch EasyDI registration and lifecycle mistakes at compile time
SlideRule.Guidance.DotNet is a Roslyn analyzer that reports code departing from Microsoft's .NET guidance as compiler warnings. Each rule has its own diagnostic ID, from SR3001, links to the Microsoft page it rests on, and takes a severity in .editorconfig. It needs no spec, no model file and no tool: reference the package, and the next build reports. A project whose own SlideRule model declares one of these rules keeps it, and the package does not report that rule. It is built with SlideRule. It needs a compiler on Roslyn 4.0.1 or later (the .NET 6 SDK, Visual Studio 2022). An older compiler builds as before, without the analyzer.
Compile-time object mapping for .NET. The Roslyn incremental generator is packaged as an analyzer and is not a runtime dependency.
MSBuild tasks that enforce Novolis safe licenses: own PackageLicenseExpression and dependency SPDX allowlist (MIT / Apache-2.0).
Zenvoy.Results: a high-performance, zero-allocation Result pattern for .NET. Result and Result<T> value types, typed errors, railway-oriented functional and async extensions, and an analyzer that catches ignored results. Native AOT and trimming friendly, no dependencies.
Zero-dependency high-performance job scheduler for .NET 10 and .NET 11 (multi-targeted): cron + interval recurring jobs, one-shot timers, background queue, retries, per-function concurrency gates and overlap policies. Compile-time registration via the companion QuickJob.Generators analyzer (zero reflection, AOT-clean). In-memory by design, with an IJobStore seam for later node coordination.
Baselines the execution-capable surface of resolved NuGet dependencies. Detects new or changed MSBuild, compiler-extension, source/content, and native package assets.
See your .NET dependency injection graph. Finds captive dependencies, missing registrations, cycles and more in the real IServiceCollection of your app.