Backend | DOTNET

The .NET Libraries Worth Knowing in 2026

Mostly the Ones Nobody Talks About

Every “top NuGet packages” list has the same names on it. Newtonsoft.Json, Serilog, Polly, AutoMapper, xUnit. You already know those. This list is different: it’s mostly libraries that solve a real problem well but haven’t made it into the standard listicle rotation, plus a few that are climbing fast enough that skipping them would be a mistake.

There’s a reason dependency choice got more scrutiny in the last year and a half. AutoMapper, MediatR and MassTransit all announced moves to commercial licensing, and FluentAssertions did the same at v8. A lot of teams opened their .csproj files for the first time in years and found packages nobody had thought about since 2019. Vetting matters now.

For non members use this link to read the full story

So I checked each library here before writing about it: GitHub stars, the date of the most recent NuGet publish, and whether the repo is actually being worked on or just sitting there. All figures are as of 15 August 2026. Where something has a warning sign, I say so.

1. Riok.Mapperly

With AutoMapper going commercial, Mapperly became the default answer, and it’s a genuine upgrade rather than a consolation prize. It’s a source generator: your mapping code is written at compile time, so you can open it, read it, and step through it in a debugger. Mistyped property names become build errors instead of runtime surprises.

2. Mediator by martinothamar

Same idea applied to the mediator pattern. Handlers are discovered at compile time via source generation, missing or duplicate handlers become build diagnostics instead of runtime exceptions, and it works under Native AOT. The API is close enough to MediatR that migration is mostly a namespace change.

3. TUnit

Tests are discovered by source generator, run in parallel by default, and work under Native AOT. It has [DependsOn] and [NotInParallel] for controlling ordering where you actually need it, plus built-in AOT-compatible mocking. The performance gap on data-driven tests is not subtle: the project's own benchmarks put it at roughly 14ms against 500ms+ for xUnit and NUnit on the same suite.

It’s at version 1.63 with a release cadence measured in days. Worth starting a new project on; think harder before migrating a large existing suite.

4. ZiggyCreatures.FusionCache

This is the one I’d most like more people to know about. FusionCache is a hybrid cache: L1 in memory, optional L2 distributed, with a backplane to keep nodes in sync. But the reason to use it isn’t the layering, it’s the failure handling. Cache stampede protection means a hundred simultaneous misses on the same key result in one factory call, not a hundred. Fail-safe means that when your database is down and the entry has expired, you get stale data instead of an exception.

5. ZLinq

From Cysharp, the team behind MessagePack-CSharp. ZLinq gives you struct-based enumerables, so a chain of Where().Select().ToArray() allocates nothing for the intermediate steps. It claims roughly 99% compatibility with .NET 10's LINQ surface, adds LINQ over Span<T>, SIMD-vectorised operators where applicable, and a "LINQ to Tree" API for querying file systems and JSON.

6. Verify

Instead of writing thirty Assert.Equal calls against a complex object graph, you serialise the result once, eyeball it, and commit it. Later runs diff against that file and pop your configured diff tool when they disagree. It's excellent for API response shapes, generated SQL, source generator output, and rendered documents. It’s used by Humanizer, NSwag, BenchmarkDotNet, Spectre.Console and Aspire, which tells you it holds up on real projects.

One practical note: Verify.Xunit is deprecated in favour of Verify.XunitV3. Use the V3 package on new work.

7. Vogen

If your codebase passes int userId and int orderId around and you've ever swapped them by accident, Vogen fixes that class of bug at compile time. It generates strongly-typed value objects from a single attribute, with optional validation baked into the factory so an invalid instance can't exist.

[ValueObject<int>]
public partial struct CustomerId
{
    private static Validation Validate(int value) =>
        value > 0 ? Validation.Ok : Validation.Invalid("Must be positive");
}

Now CustomerId.From(42) is the only way in, and passing an OrderId where a CustomerId belongs doesn't compile. Benchmark overhead versus the raw primitive sits in the 16–23% range on the project's own numbers, with negligible memory cost.

8. linq2db

Everyone reaches for EF Core or Dapper and stops looking. linq2db sits between them: real type-safe LINQ, but no change tracking and no hidden materialisation cost. It gives you explicit joins, CTEs, window functions, and proper bulk copy, all through LINQ rather than magic strings. When you need SQL that EF Core won’t generate cleanly, this is often better than dropping to raw strings. nopCommerce and Bitwarden ship it. It shipped a release eight days before I wrote this.

9. Meziantou.Analyzer

A Roslyn analyzer package with rules covering CancellationToken propagation, culture-sensitive string comparison, IFormatProvider omissions, LINQ inefficiencies, regex timeouts and certificate validation. Many ship with automatic fixes. It catches the category of bug that only shows up in production under a different locale.

FluentAssertions, Marten and linq2db all run it in their own builds. Add it, set <MeziantouAnalysisMode>all-suggestions</MeziantouAnalysisMode>, and work through the list gradually.

10. MiniExcel

ClosedXML and EPPlus load the workbook into memory. On a large export that’s the difference between a few megabytes and a few hundred. MiniExcel streams row by row, has no Office or COM dependency, and the whole package is under 800KB. It handles LINQ-based import with deferred execution, export from objects, dictionaries, DataTable or IDataReader, and template-based generation.

11. PolySharp

If you maintain anything on .NET Standard 2.0 or .NET Framework, PolySharp source-generates the compiler-required types for init, required, records, ranges, collection expressions and module initializers, so you can write current C# without multi-targeting hacks. It's the kind of dependency you add once and never think about again. AutoMapper, Serilog, BenchmarkDotNet and RestSharp all use it.

12. AwesomeAssertions

Not a novel library, but relevant. It’s a community fork of FluentAssertions built from the last Apache-2.0 commits, so .Should().Be() keeps working without a licence question. Active maintenance, six named maintainers, and adoption that's already at 18.2M downloads.