.NET 11 vs .NET 10: What's New and Should You Upgrade

.NET 11 is STS with two years of support; .NET 10 stays LTS. Here's what changed in the runtime, C# 15 and ASP.NET Core — and who should move now.

Announcing .NET 11 illustration with two cartoon robots launching a purple rocket marked 11 into a starry sky
Announcing .NET 11. Image: Microsoft.

.NET 11 shipped on November 10, 2026, and the short version is this: it's a Standard Term Support (STS) release with two years of servicing, not the long-term support release .NET 10 was a year ago. If your team upgrades every release regardless of support tier, .NET 11 is worth it mainly for Runtime Async leaving preview, a faster Native AOT CLI host on by default, and C# 15's union types. If you upgrade only for LTS releases, or your apps are still happily running on .NET 10, there's less urgency — .NET 10 remains fully supported as an LTS release, and nothing in .NET 11 forces a move. Here's what actually changed, and who should upgrade now versus wait.

The essentials:

  • .NET 11 released November 10, 2026, as a Standard Term Support (STS) release with two years of support; .NET 10 (released November 2025) is the current Long Term Support (LTS) release with three years of support.
  • .NET 8 and .NET 9 reached end of support on the same day .NET 11 shipped, so anyone still on those versions needs to move now regardless of which release they pick.
  • Headline runtime change: Runtime Async is no longer a preview feature — it no longer requires <EnablePreviewFeatures> for apps targeting net11.0, and the runtime libraries themselves now compile with it on.
  • C# 15 (default on .NET 11) adds union types with exhaustiveness checking, closed hierarchies, collection expression arguments, extension indexers and labeled break/continue.
  • Native AOT CLI host and a warm MSBuild server are both on by default in .NET 11's SDK, a change from .NET 10 where they were opt-in or unavailable.

Support policy: why STS vs LTS is the first decision

Microsoft alternates .NET releases between Long Term Support (three years, even-numbered versions like .NET 8 and .NET 10) and Standard Term Support (two years, odd-numbered versions like .NET 9 and .NET 11). .NET 11 is the STS release in that cycle, meaning it gets the same quality bar and servicing cadence as an LTS release, just for a shorter window — two years instead of three. .NET 10 doesn't stop being supported just because .NET 11 exists; it continues on its three-year LTS clock. The practical rule Microsoft has used for years still applies: production teams that prioritize stability over the newest features should stay on LTS releases and skip STS releases entirely unless a specific STS-only feature is worth the shorter support window. Teams that always track the latest release regardless of support length should move to .NET 11.

One date matters more than the STS/LTS distinction for some teams: .NET 8 and .NET 9 both reached end of support on November 10, 2026, the same day .NET 11 shipped. If you're running either of those, this isn't really a ".NET 11 vs .NET 10" decision — you need to move to a supported version immediately, and the LTS-vs-STS calculus above determines which one.

Runtime Async: the headline runtime change

The single biggest runtime change in .NET 11 is that Runtime Async has moved out of preview. In .NET 10, using it required opting into preview features explicitly. In .NET 11, projects that target net11.0 get runtime-native async without that flag, and the runtime libraries themselves are now compiled with runtime-async=on. Microsoft's own developer blog describes the payoff as cleaner stack traces and lower overhead for async code, plus a set of follow-on JIT improvements: the JIT now compiles a dedicated runtime-async version of synchronous task-returning methods, async continuations can skip capturing ExecutionContext when there's no ambient state to carry, and tail-merged suspension points reduce generated code size. .NET 10 shipped JIT work of its own — inlining, devirtualization and stack-allocation improvements — but nothing that touches the async model itself the way Runtime Async does in .NET 11.

C# 15 vs C# 14: language changes

C# 14, which shipped with .NET 10, focused on ergonomics: field-backed properties, unbound generic nameof, implicit Span<T>/ReadOnlySpan<T> conversions, parameter modifiers in lambdas without explicit types, partial instance constructors and events, static extension blocks, null-conditional assignment, and user-defined compound and increment/decrement operators. C# 15, the default language version on .NET 11, goes further into the type system: union types with exhaustiveness checking in switch expressions, closed hierarchies, collection expression arguments (letting you pass configuration like a comparer directly inside a collection literal), extension indexers, and labeled break/continue for exiting nested loops precisely. Memory safety work is included but still in preview in C# 15, so it isn't a reason to upgrade on its own yet.

Libraries and SDK: what else moved

.NET 11's library additions lean toward things backend and tooling teams will notice before frontend developers do: Zstandard compression support in System.IO.Compression, System.Text.Json support for C#/F# unions and JSON Lines output, new IEEE 754 decimal floating-point types (Decimal32, Decimal64, Decimal128), a generic Complex<T>, expanded Process APIs for run-and-capture and suspended starts, and experimental post-quantum APIs (composite ML-KEM and HPKE). On the SDK side, the Native AOT CLI host and a warm MSBuild server are both enabled by default — in .NET 10, Microsoft.Testing.Platform support for dotnet test and native shell tab-completion were the SDK's headline additions, while .NET 11 adds a new dotnet run -e flag for environment variables, reproducible container image digests, and Podman support for multi-architecture container builds. EF Core 11 requires .NET 11 outright and adds experimental SQL Server vector search alongside fewer unnecessary joins and better GroupBy translation.

ASP.NET Core, Blazor and MAUI

ASP.NET Core 11 generates OpenAPI 3.2 documents by default — Microsoft's release notes list this as a breaking change for tooling that expects OpenAPI 3.0 or 3.1 output — and adds asynchronous validation, union support in JSON request/response bodies, a new CacheView Blazor component, and SignalR connections that can refresh authentication without reconnecting. ASP.NET Core 10 had introduced Blazor WebAssembly preloading, automatic memory pool eviction and passkey support for Identity; .NET 11 builds on that rather than replacing it. In .NET MAUI, CoreCLR becomes the default runtime in .NET 11, XAML hot reload is in preview, and the Microsoft.Maui.Controls.Compatibility package has been removed entirely — any app still referencing it needs to migrate before upgrading, which is one of the few hard blockers in this release rather than just a nice-to-have.

F#, Windows Forms and WPF

F# 11 is a quieter release than the C# side: lower compiler memory use, fewer allocations inside FSharp.Core collections, and new ways to bound concurrent async work, rather than new syntax. That continues a pattern from .NET 10, where F#'s changes to FSharp.Core applied automatically to projects on the new SDK unless a lower version was explicitly pinned. On the Windows desktop side, .NET 10 shipped WinUI 3 as the recommended path for new apps alongside clipboard updates and ported UITypeEditors for Windows Forms, plus Fluent style changes for WPF. .NET 11 continues recommending WinUI 3 for new projects, adds an opt-in modern visual styles mode to Windows Forms, and keeps WPF's .NET 11 release focused on reliability fixes rather than new features — neither framework sees a dramatic change this cycle, so desktop teams have less reason to rush an upgrade than web or backend teams do.

Performance and reliability beyond Runtime Async

Outside the headline async work, .NET 11's JIT picks up bounds-check elimination, redundant checked-context removal, devirtualization improvements, switch-expression folding, constant-folding for SequenceEqual, and redundant branch elimination, plus new Arm SVE2 intrinsics and a faster Math.BigMul on x64 that now emits a single MUL instruction. Native AOT gets faster interface dispatch through a shared dispatch helper, which both shrinks binary size at call sites and improves throughput for interface-heavy code — relevant if you've adopted Native AOT for container workloads where image size and cold-start time both matter. .NET 11 also adds in-process crash report logging that captures the managed stack trace and runtime state before a process exits, available on Linux, macOS and mobile platforms, which should make diagnosing production crashes in containerized or mobile deployments noticeably less painful than relying on process-exit codes alone. .NET 10's runtime work, by comparison, centered on JIT inlining, method devirtualization, stack allocations and AVX10.2 support — solid but narrower gains that didn't touch crash diagnostics or interface dispatch the way .NET 11 does.

.NET 11 vs .NET 10 at a glance

Area.NET 10 (Nov 2025).NET 11 (Nov 2026)
Support tierLTS — 3 yearsSTS — 2 years
Default C# versionC# 14C# 15
Async modelRuntime Async not availableRuntime Async out of preview, on by default for net11.0
Native AOT CLI hostNot availableOn by default
MSBuild serverOpt-inWarm server on by default
JSON unions (System.Text.Json)Not supportedC#/F# union support, JSON Lines output
OpenAPI default (ASP.NET Core)3.0/3.1-oriented toolingOpenAPI 3.2 by default (breaking change)
.NET MAUI default runtimeMono-basedCoreCLR
EF Core compatibilityEF Core 10EF Core 11 (requires .NET 11)

Breaking changes to check before upgrading

Three changes are worth testing for specifically before moving production workloads to .NET 11. First, updated minimum hardware requirements for x86/x64 and Arm64 mean some older CPUs may no longer be supported targets — check the official breaking-changes list if you deploy to older or constrained hardware. Second, ASP.NET Core 11's default OpenAPI 3.2 output is explicitly flagged as a breaking change for any tooling, client generators or documentation pipelines built around OpenAPI 3.0 or 3.1. Third, .NET MAUI apps still referencing Microsoft.Maui.Controls.Compatibility must migrate off that package first, since it no longer ships at all. None of these are reasons to avoid .NET 11 outright, but all three are things a PHP or Node migration checklist wouldn't warn you about — they're specific to this release.

Who should upgrade now, and who should wait

Move to .NET 11 now if you're currently on .NET 8 or .NET 9 — both lost support the same day .NET 11 shipped, so you need a supported version regardless, and .NET 11 gets you the newest language and runtime features. Also move now if your app is built around heavy async workloads and would benefit from Runtime Async's lower overhead and cleaner stack traces, or if you specifically need OpenAPI 3.2, the new JSON union support, or EF Core 11's vector search. Stay on .NET 10 for now if your organization follows an LTS-only upgrade policy — you have until .NET 10's support window closes in 2028 — or if you depend on Microsoft.Maui.Controls.Compatibility and haven't migrated yet. Either way, don't stay on .NET 8 or .NET 9: both are now unsupported, which means no further security patches.

What to do next

Download .NET 11 from Microsoft's official site and run your test suite against it in a staging environment before touching production, paying particular attention to the OpenAPI default change if you have API tooling downstream, and to the MAUI Compatibility package removal if your mobile app uses it. If you're weighing a broader backend refresh this cycle, our PostgreSQL 19 vs PostgreSQL 18 comparison and PHP 8.6 vs PHP 8.5 comparison walk through the same kind of staged-upgrade decision for the rest of a typical web stack.

Frequently asked questions

Is .NET 11 LTS or STS?

STS (Standard Term Support), with two years of servicing. .NET 10 remains the current LTS (Long Term Support) release with three years of support.

Do I need to upgrade from .NET 10 to .NET 11 right away?

No. .NET 10 is still fully supported as an LTS release. Upgrade now only if you specifically want a feature that shipped in .NET 11, like Runtime Async out of preview or C# 15's union types; otherwise you can wait.

What happens if I'm still on .NET 8 or .NET 9?

Both reached end of support on November 10, 2026, the same day .NET 11 shipped. You need to move to either .NET 10 or .NET 11 now to keep receiving security patches.

What's the biggest new feature in .NET 11?

Runtime Async leaving preview. Apps targeting net11.0 get runtime-native async without enabling preview features, with cleaner stack traces and lower overhead, plus related JIT improvements.

Does .NET 11 break any existing apps?

It can. Watch for three things: updated minimum CPU requirements, ASP.NET Core 11 defaulting to OpenAPI 3.2 output instead of 3.0/3.1, and the complete removal of the Microsoft.Maui.Controls.Compatibility package in .NET MAUI.

Sources

More on .NET 11 →.NET 11.NET 10C# 15MicrosoftSoftware development
Felix Moreau
Written byFelix Moreau

Felix Moreau writes Pandromeda's software coverage and how-to guides. He covers Windows, macOS and Linux updates, the apps people rely on, emulators and developer tools, and turns official documentation into clear, numbered steps that work on the current version.

More from Software & Guides

See all