Coding is Love
News 4 min read

.NET 11 released with C# 15 union types and Runtime Async preview

Microsoft released .NET 11 on November 10, 2026, with C# 15 as the default language, a preview of runtime-native async, hundreds of JIT and runtime optimizations, and new minimum CPU requirements. It is a Standard Term Support (STS) release with two years of support, and it lands on the same day .NET 8 and .NET 9 reach end of support, so teams still on those versions now have to move to .NET 10 LTS or .NET 11. Details below come from Microsoft’s .NET 11 announcement and the What’s new in the .NET 11 runtime docs.

What’s new

C# 15 and F# 11

  • C# 15 is the default for net11.0 projects. Its headline features are union types, closed hierarchies, collection expression arguments, extension indexers, and labeled break and continue. The memory safety work stays in preview.
  • F# 11 cuts compiler memory use and allocations in FSharp.Core collection operations and adds ways to bound concurrent async work.
  • System.Text.Json supports C# and F# unions (new to the format? see our in-depth JSON tutorial).

Runtime Async (preview)

The biggest runtime change is Runtime Async: instead of the C# compiler generating a state-machine class for every async method, the runtime itself tracks suspension and resumption. Microsoft says this gives cleaner stack traces, better debugging and lower overhead. It is still a preview feature, turned on per project:

<PropertyGroup>
  <Features>runtime-async=on</Features>
</PropertyGroup>

A net11.0 project no longer needs EnablePreviewFeatures for it. The .NET libraries themselves are already compiled with Runtime Async on. In Microsoft’s example, a live stack trace three async calls deep drops from 13 frames of state-machine plumbing to the 5 real method calls. Breakpoints now bind inside runtime-async methods, and it works with Native AOT and ReadyToRun. The old DOTNET_RuntimeAsync environment variable is gone; to opt out per project, set <UseRuntimeAsync>false</UseRuntimeAsync>.

Separately, every Task and ValueTask continuation now skips capturing and restoring ExecutionContext when there is nothing to restore, which cuts overhead in busy async code even without Runtime Async.

JIT and performance

  • Fewer bounds checks: patterns such as i + cns < len, values[^1] and span[0] after an IsEmpty guard no longer pay for a check.
  • More devirtualization: generic virtual methods and default interface methods on generic interfaces can now be devirtualized, and Activator.CreateInstance<T>() results are treated as an exact type.
  • Constant folding: string.Equals and SequenceEqual on two constants (including UTF-8 literals) fold to true or false.
  • Hardware FP16: Half arithmetic and conversions use FP16 instructions on supporting x64 (AVX10.1, F16C) and Arm64 hardware, with no code changes.
  • Native AOT routes interface calls through a patchable dispatch helper, for smaller call sites and better throughput.
  • ReadyToRun now specializes Comparer<T>.Default and EqualityComparer<T>.Default; Microsoft reports up to 20x faster collection operations that use them.
  • On Linux, Guid.NewGuid() uses the getrandom() syscall, for about 12% more throughput.

Microsoft points to Stephen Toub’s “Performance Improvements in .NET 11” post for full benchmarks.

New minimum hardware

.NET 11 raises the x86/x64 baseline from x86-64-v1 to x86-64-v2 (adding SSE4.2, POPCNT and others) on Windows, Linux and macOS, and Windows on Arm64 now needs the LSE instruction set. On older CPUs, apps fail to start with a message that the CPU is missing baseline instruction sets. Microsoft says the x64 change covers every chip Intel and AMD still support, the oldest having gone out of support around 2013. The runtime can also start on machines with more than 1024 logical processors.

Libraries, SDK and frameworks

  • Libraries: a one-shot run-and-capture Process API, Zstandard compression in System.IO.Compression, four in-memory stream adapters and LINQ FullJoin.
  • SDK: the CLI host is Native AOT compiled by default, the MSBuild server stays warm between commands, dotnet test gets run-level timeouts and failure limits, container publishing produces reproducible digests, and NuGet adds a minimum package publication age setting.
  • ASP.NET Core and Blazor: async validation for Minimal APIs and Blazor forms, OpenAPI 3.2 as the default document version, SignalR auth refresh without reconnecting, and a CacheView component for static SSR.
  • EF Core 11 (requires .NET 11): fewer unnecessary joins, FullJoin translation, complex types and JSON columns with TPT and TPC inheritance, and experimental SQL Server vector search.
  • .NET MAUI: CoreCLR is now the default runtime on every platform; Native AOT on Android is experimental.

What it means for developers

If you are on .NET 8 or .NET 9, both are out of support as of today. The safe target is .NET 10, which remains LTS; .NET 11 is for teams that want C# 15 and the new performance work and can upgrade again within two years. Before upgrading, check old build agents and customer machines against the new CPU minimums.

To try it, install the SDK from dotnet.microsoft.com and use an up-to-date Visual Studio 2026 or VS Code with C# Dev Kit. Microsoft’s quick test:

dotnet new console -n HelloDotnet11 -f net11.0
dotnet run --project HelloDotnet11

Runtime Async is the feature to test now on a branch: turn it on and compare throughput, binary size and profiler output, since Microsoft says it wants reports of both gains and regressions before the feature leaves preview.

Sources