What's New in .NET 11 and C# 15: Every Major Feature Explained

,.NET 11 is currently in release candidate, with general availability expected in November 2026 the same month .NET 8 and .NET 9 both reach end of support. That timing makes .NET 11 worth understanding now, even if .NET 10 remains the safer immediate upgrade target for most production applications.

This guide breaks down what's actually new — in the runtime, in C# 15, in the libraries, and in the SDK — based on Microsoft's own official release documentation, in plain language rather than changelog shorthand.

Microsoft ships a new major .NET version every November without fail, alternating Long Term Support (LTS) and Standard Term Support (STS) designations. .NET 10, released a year earlier, was the LTS release; .NET 11 follows the STS pattern, meaning it's built for teams that want to move fast and adopt new language and runtime capabilities sooner, rather than the multi-year stability window an LTS release is designed around.

.NET 11 at a Glance

Union Types: The Biggest C# Language Feature in Years

If you've used TypeScript or F# and missed having discriminated unions in C#, this is the change you've been waiting for. C# 15 introduces a new union keyword that lets a value be exactly one of several defined types and the compiler enforces that every possible case is handled.

public record class Cat(string Name);
public record class Dog(string Name);
public record class Bird(string Name);

public union Pet(Cat, Dog, Bird);

Pet pet = new Dog("Rex");

string name = pet switch
{
    Dog d => d.Name,
    Cat c => c.Name,
    Bird b => b.Name,
};

The practical win: that switch expression needs no default case. The compiler already knows a Pet can only ever be a Cat, a Dog, or a Bird if a new case type gets added to the union later and a switch statement somewhere doesn't handle it, the compiler flags it immediately instead of letting a missed case fail silently in production.

System.Text.Json has already been updated to serialize and deserialize these new union types directly, and ASP.NET Core uses union metadata to describe return types in OpenAPI documentation so this isn't an isolated language feature sitting apart from the rest of the ecosystem.

Runtime Async: A Foundational Shift, Not Just an Optimization

Every C# developer has written async/await code without thinking much about what happens underneath the compiler quietly rewrites your method into a state machine. In .NET 11, that changes. Runtime Async moves async handling into the runtime itself, rather than relying entirely on compiler-generated state machines.

The result is cleaner stack traces when something goes wrong and lower performance overhead. Runtime Async is still a preview feature that you opt into with <Features>runtime-async=on</Features> in your project file, but unlike earlier previews t no longer requires the preview-features flag for projects targeting net11.0. The .NET runtime libraries themselves are already compiled with runtime-async=on.

Underneath that headline change, Microsoft also added JIT compilation for a dedicated runtime-async version of synchronous task-returning methods, async continuations that skip unnecessary ExecutionContext capture, and tail-merged suspension points that reduce generated code size all adding up to faster, lighter await calls in code that opts in.

The Rest of C# 15

Union types get the headlines, but C# 15 ships several other additions worth knowing:

• Closed hierarchies: a closed modifier that restricts which types can inherit from a base class, enabling the same kind of exhaustive pattern-matching benefit as union types for class hierarchies.
• Collection expression arguments: more flexible syntax for passing arguments into collection expressions.
• Extension indexers: extension members can now define indexer syntax (obj[index]), closing a gap left by C# 14's extension members support.
• Labeled break and continue: the ability to break or continue a specific outer loop by name in nested loop structures, instead of relying on workaround flags.
• Memory safety improvements: additional compiler-enforced safety rules around memory access patterns.

Runtime and Performance Improvements

Beyond Runtime Async, .NET 11's runtime picks up a meaningful list of lower-level performance work:

• JIT improvements including bounds-check elimination, redundant checked-context removal, devirtualization, switch-expression folding, and redundant branch elimination.
• New hardware intrinsics, including Arm SVE2 support, AVX-VNNI-512 for vectorized multiply-add workloads, and a faster Math.BigMul on x64.
• CoreCLR on WebAssembly now runs the full libraries test suite end to end a meaningful maturity milestone for .NET-in-the-browser scenarios.
• Hardware FP16 instructions for Half arithmetic and conversions on both x64 and Arm64.
• NativeAOT improvements, including faster interface dispatch through a shared dispatch helper, reducing binary size and improving throughput for interface-heavy workloads.
• SIMD lane construction APIs (CreateGeometricSequence, Zip, Unzip, and the Concat family) across the full range of vector types.

None of this requires code changes to benefit from it's the kind of improvement where .NET simply keeps getting faster underneath applications that don't change a single line.

Library Updates Worth Knowing

The System.Text.Json additions are particularly relevant if you're building APIs JSON Lines output in particular is a format increasingly used for streaming and log-style data, and having it built in removes a common third-party dependency.

SDK and Tooling Changes

dotnet test gets the most significant overhaul in this release: new options including --no-dependencies, --use-current-runtime, --timeout, --maximum-failed-tests, live display of in-flight tests, and notably support for Android, iOS, macOS, and Mac Catalyst test projects with device selection built in.

Beyond testing, the SDK picks up smaller installers on Linux and macOS through assembly deduplication, support for creating and editing solution filter files from the CLI, a new dotnet run -e option for passing environment variables, and expanded file-based app support that lets a single-file app include compiled DLL references directly. Container publishing also improves, with multi-architecture builds via Podman, reproducible image digests, and a preference for platform-native local runtimes over Docker where available.

What About ASP.NET Core, EF Core, and Desktop Frameworks?

.NET 11's runtime, library, and SDK changes apply broadly, but the major application frameworks each get their own dedicated release notes rather than being folded into the core overview.

• ASP.NET Core for .NET 11 has its own release notes covering web framework-specific changes.
• EF Core 11 ships alongside .NET 11 with its own data-access improvements and breaking changes worth reviewing before upgrading a data-heavy application.
• Windows Forms and WPF both receive .NET 11-specific updates for desktop application developers.

If your application is primarily a web API or data-heavy service, review the ASP.NET Core and EF Core release notes specifically rather than assuming the runtime-level changes above tell the whole story.

Should You Upgrade to .NET 11 Now?

For most production applications, not yet and that's by design, not a criticism of the release. .NET 11 is a Standard Term Support (STS) release, meaning it carries a shorter support window than an LTS release like .NET 10. RC1 includes a go-live support license, but Runtime Async is still an opt-in preview, the updated memory-safety rules are preview-only, and .NET 11 raises the minimum CPU requirements, so check your hardware first.

The more useful move for most businesses right now is treating .NET 11 as something to evaluate try it on a side project, see how union types and Runtime Async actually feel in practice — while keeping production workloads on .NET 10's longer-term support window. That's especially true for any team currently planning a migration off .NET 8 or .NET 9, where .NET 10 remains the steadier landing spot.

Frequently Asked Questions

What is the .NET 11 release date?

.NET 11 is currently in release candidate, with general availability scheduled for November 10, 2026, following Microsoft's standard annual November release cadence.

What is the biggest new feature in .NET 11?

Union types in C# 15 are widely considered the most significant addition the first native discriminated-union support C# has had, enabling exhaustive, compiler-checked pattern matching over a closed set of types.

Is .NET 11 an LTS or STS release?

.NET 11 is a Standard Term Support (STS) release, meaning it carries a shorter support window than an LTS release like .NET 10, which is currently supported through November 2028.

What is the difference between .NET 11 and .NET 10?

.NET 10 is the Long Term Support (LTS) release, supported through November 2028, which makes it the steadier choice for production applications. .NET 11 is a Standard Term Support (STS) release with a shorter support window. It adds C# 15 union types, an opt-in preview of Runtime Async, JIT and SIMD improvements, and a major dotnet test overhaul, and it raises the minimum hardware requirements.

When do .NET 8 and .NET 9 reach end of support?

Both .NET 8 and .NET 9 reach end of support on November 10, 2026, the same month .NET 11 is scheduled to ship. If your applications still run on either version, plan your move to .NET 10 (LTS) now. Our guide to .NET 8 and .NET 9 end of support in 2026 covers the timeline in detail.

Should I upgrade to .NET 11 as soon as it's released?

For most production applications, no — especially since Runtime Async is still an opt-in preview and .NET 11 raises the minimum hardware requirements. .NET 10's longer LTS support window makes it the safer production target, with .NET 11 better suited to evaluation and side projects initially.

What is Runtime Async and why does it matter?

Runtime Async moves async/await handling into the .NET runtime itself rather than relying entirely on compiler-generated state machines, producing cleaner stack traces and lower overhead. In .NET 11, it is still an opt-in preview feature, but it no longer requires the preview-features flag for projects targeting net11.0.

Do I need to change my code to benefit from .NET 11's performance improvements?

No. Most of the runtime and JIT improvements — including bounds-check elimination, new hardware intrinsics, and NativeAOT dispatch improvements apply automatically to existing code once you target .NET 11, with no code changes required.

Who can help me migrate or upgrade my application to .NET 10 or .NET 11?

DotStark's .NET development services include .NET upgrade and migration, application modernization, and ASP.NET Core development, and you can hire .NET developers to extend your team. Talk to our team for a free assessment of your current applications.

Planning Your .NET Roadmap Beyond .NET 11

Whether you're evaluating .NET 11's new features for an upcoming project, or working through a migration plan before .NET 8 and .NET 9 lose support this November, getting the sequencing right matters. As an experienced .NET development company, DotStark can help you plan the right upgrade path for your applications whether that's landing on .NET 10 now or evaluating .NET 11 for what comes next.

Our .NET development services cover .NET upgrade and migration, legacy application modernization, and custom ASP.NET Core development. If you need extra capacity, you can hire .NET developers from our team to build, migrate, or maintain your applications.

Source: Microsoft, "What's new in .NET 11," .NET Documentation (release candidate 1)  learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-11/overview