dotnet-fast — fast .NET formatter, linter, build cache & test sharding

Rust-powered .NET workspace tooling: a dotnet format alternative, a C# linter, a code-health scoreboard, 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 and no Roslyn, so they start in milliseconds and run common jobs 10–100× faster than the official tools (how that is measured); the documented exception is lint --deep, which runs your project's real Roslyn analyzers.

Install

dotnet tool install -g RDLL.dotnet-fast
dotnet tool update  -g RDLL.dotnet-fast   # already installed? update to the latest

Windows x64 and Linux x64, and the .NET 10 SDK is a hard floor. Windows x64 is the verified platform. Linux x64 ships as a static binary but is not yet under the release parity gates, and macOS has no binary: the install succeeds there, but the first run fails. Prerequisites, the repo-pinned manifest form, verifying the download, updating and uninstalling: install.md.

First run

dotnet-fast lint path/to/App.sln          # report findings, non-zero exit on any (the CI gate)
dotnet-fast lint --fix path/to/App.sln    # apply every safe fix in one pass
dotnet-fast metrics path/to/App.sln       # score the codebase against ten code-health budgets

In CI

- run: dotnet tool install -g RDLL.dotnet-fast
- run: dotnet-fast lint --ci .                             # exit 1 on any finding — the gate
- run: dotnet-fast affected --ci --format traversal --output-name affected .

Exit codes: 0 clean, 1 findings, 2 a dotnet format-compat verify/apply failure, 166 no projects affected (skip the downstream jobs — not a failure). Test != 0, and handle 166. On a pull request --ci scopes the lint report to the lines you changed, so old debt in a touched file does not fail the build. Copy-paste Actions and Azure Pipelines wiring: ci.md.

Commands

Lint & format

Command	What it's for
lint	Report formatting + lint findings (the fast CI gate). --fix applies the safe fixes; --deep adds your real Roslyn analyzers. Guides: rules · ported analyzers · deep linting · guardrails.
rewrite	Structural search & replace (codemod): find every occurrence of a C# pattern regardless of formatting, preview a rewrite as a diff (read-only — no --write), --check to gate CI. A match it cannot prove safe to preview as a rewrite is withheld, never guessed at.

Code health

Command	What it's for
metrics	Score a codebase against fourteen budgets: complexity, coverage, CRAP, surviving mutants, dead code. Guide: metrics.md.
dead-code	Types and members nothing in production reaches, plus a distinct test-only category. Guide: dead-code.md.
dead-dependencies	Unused PackageReferences and ProjectReferences, with an optional build-verified fix. Guide: dead-dependencies.md.
bom	Software Bill of Materials — CycloneDX or SPDX — without a build. Guide: bom.md.
doctor	Build-free scan for common workspace problems: duplicate references, CPM conflicts, lock-file drift.
insights	Analytics over recorded build/test/lint history: hotspots, trends, regressions, HTML report. Guide: insights.md.

CI accelerators

Command	What it's for
affected	List the projects a Git change set affects, plus their reverse-dependents, for scoped CI. Guide: ci.md.
build	Remote build cache (preview): restore prior build outputs instead of rebuilding on a clean checkout. Guide: build-cache.md.
test-plan	NUnit test sharding for CI agents, planned from source before any test assembly is built. Guide: test-sharding.md.

Also: hooks installs Git hooks that run lint --fix --staged on commit (no husky, no JS toolchain); editorconfig explains, infers or seeds your .editorconfig (guide); cache grants the build cache's storage account the data-plane role CI needs, without a separate az step; update picks the right dotnet tool update form for how your copy was installed.

format, style, whitespace and analyzers are accepted as dotnet format-compatible aliases. Add --json to any command for machine-readable results and timing; lint, affected, doctor, metrics and dead-dependencies also emit SARIF for GitHub code scanning (code-scanning.md). lint ships 153 native CST rules (DF0001–DF0153), each listed with its --fix status on the rules page, and a large set of popular Roslyn analyzers is re-implemented natively and runs on the fast path by default — no --deep needed.

Documentation

Every page, grouped by task → — install, the command reference, CI wiring, code health, the build cache, test sharding, the support matrix, benchmarks, the security position. Plus runnable examples/.

Issues & feedback

Found a bug, a formatting mismatch vs dotnet format, or want a feature? Open an issue — this repo is the user-facing home for dotnet-fast and where reports are triaged. The implementation lives in a separate repository; you don't need it to use the tool.

Release notes

Plain-English notes for each version: RELEASES.md. Each release attaches dotnet-fast-win-x64.exe and a matching .sha256, and each version of these docs is tagged vX.Y.Z.

License

Free to use under a freeware license — see LICENSE. The Software is distributed as a binary; its source is proprietary and not published. Use is permitted (including commercially within your own organization); redistribution, resale, modification and reverse engineering are not. Not affiliated with Microsoft or the .NET Foundation. Buy me a coffee ☕ if it speeds up your builds — it genuinely helps.