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 test sharding (NUnit, xUnit, MSTest) 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 and Linux x64. Windows x64 is the platform every release is built and verified on. Linux x64 ships a static binary that is not yet under the release parity gates. macOS does 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. 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, xUnit and MSTest 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.

metrics

Ten code-health budgets in one build-free pass: cyclomatic and cognitive complexity, Halstead difficulty, lines per file, dead and redundant code, dynamic usage — plus test coverage, CRAP and surviving mutants read from the coverage (Cobertura, OpenCover, LCOV, coverlet JSON) and Stryker reports your pipeline already produces. A metric you did not measure is never shown as passing. Metrics guide.

insights

Read-only analytics over the build, test and lint history dotnet-fast already records: slowest projects and fixtures, the lint finding-count trend, and a regression diff against a baseline branch — as text, JSON, or a self-contained HTML report you can open from a CI artifact.

hooks · editorconfig · cache · update

The small stuff: hooks installs Git hooks that run lint --fix --staged on commit (no husky, no JS toolchain); editorconfig explains, infers or seeds your config; cache grants the build cache's storage account the role CI needs; update picks the right dotnet tool update for how your copy was installed.

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: CI wiring · build cache · test sharding · dead code · dead dependencies · metrics · the .editorconfig guide · 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