dotnet-fast
NuGet Downloads Freeware

Fast .NET tooling —
format, lint, build cache & test sharding

A Rust-powered, instant-start alternative to dotnet format plus a C# linter — and CI accelerators: Git affected-project detection, an Azure Blob remote build cache, and NUnit test sharding for Azure DevOps and GitHub Actions. The native paths load no MSBuild or Roslyn, so they start in milliseconds and run common jobs 10–100× faster.

Get started Documentation ☕ Buy me a coffee

Install

dotnet tool install -g RDLL.dotnet-fast
dotnet tool update  -g RDLL.dotnet-fast   # update to the latest
dotnet-fast lint path/to/App.sln          # report findings (the CI gate)
dotnet-fast lint --fix path/to/App.sln    # apply every safe fix in one pass
dotnet-fast affected --ci                 # projects to build/test for this change
dotnet-fast test-plan --shards 8 --format matrix .

Windows x64 only. That is the platform every release is built and verified on, and the only one a binary ships for. Linux and macOS do not work today: the install command above succeeds there (it is a portable .NET tool package), but the first run fails with dotnet-fast native binary was not found and exit 1, because the package carries a win-x64 native binary only. linux-x64 is the first target for the 1.x line. Platform detail.

Needs the .NET 10 SDK — on .NET 9 the install fails with a message that does not say why. The install & first-run walkthrough covers prerequisites, the repo-pinned local tool manifest, a first run with real output, verifying the download, updating, and uninstalling.

What it does

lint

Report formatting + native syntax-level lint findings (the fast CI gate). --fix applies the safe fixes; --deep opts into the project's real Roslyn analyzers for the semantic rules the fast path can't run. On a PR it scopes to the lines you changed, so old debt in a touched file doesn't fail the build. Optional guardrails keep AI-written code reviewable — no explanatory comments, a line budget per method and per file, no magic numbers — off by default, each enabled from .editorconfig.

format

Apply whitespace/style formatting on a dotnet format-compatible path — no MSBuild load, starts in milliseconds.

affected

List the projects a Git change set affects (plus reverse-dependents) for scoped CI. Shallow explicit ranges deepen and retry; Azure batch builds can use the last successful build as their base.

build preview

Remote build cache backed by Azure Blob Storage: restore cached build outputs on a clean checkout instead of rebuilding; build misses and upload trusted artifacts.

test-plan preview

NUnit test sharding for parallel CI agents — discovered from source before test assemblies are built, balanced with project affinity, emitted as an ADO/Actions matrix.

doctor

Fast, build-free scan for common workspace problems (duplicate references, CPM conflicts, inconsistent lock usage, and more).

bom

Software Bill of Materials without a build: direct + transitive packages, purls, hashes, and the dependency graph as CycloneDX (JSON/XML, 1.4–1.6) or SPDX (2.2/2.3) — from lock files or restored assets, with --restore for a fresh checkout.

dead-code

Solution-wide dead-code detection: types and members nothing in production reaches, plus a distinct test-only category. Conservative — everything reported is safe to delete.

dead-dependencies

Unused PackageReference/ProjectReference detection plus MSBuild smells (orphaned central versions, duplicates), with optional build-verified --fix.

Native paths use no MSBuild or Roslyn — analysis is syntactic (no type information), which is the speed trade-off made explicit. The exceptions are documented and opt-in: lint --deep runs your project's real Roslyn analyzers for semantic rules, and build orchestrates the real dotnet build on a cache miss.

Built for speed

10–100×
faster on common jobs
~240×
startup-bound format check
6–23×
affected detection
ms
native cold start
679
Roslyn analyzers ported to the native path (curated default available)

Each figure comes from a dated, output-verified run — method, machine, raw numbers and the cases where we are not faster are in the benchmark methodology. The affected range spans a 60-project chain and a 300-project chain on different dates; process-spawn cost on the host moves it more than the tool does. Every run reports its own cost; add --json to any command for machine-readable results and timing.

Made for CI

Guides: build cache · test sharding · dead code · dead dependencies · bill of materials · ported analyzers · benchmark methodology · security & supply chain · how releases are made · full command reference.

Support the project

dotnet-fast is free to use. If it speeds up your builds and CI, a coffee genuinely helps and is much appreciated.

☕ Buy me a coffee