The language features

C# 15 is now the default language version. The marquee feature is union types, and it's honestly one of the most-anticipated C# additions in years. A union lets a value be exactly one of a closed set of case types, with the compiler making sure you've handled every single case. Miss one, and you get a build-time warning instead of a runtime surprise at 3 AM.

If you've used discriminated unions in F# at all, this feels familiar. C# unions are built to compose existing types without forcing them into an inheritance hierarchy, which is the part long-time F# developers found grating for years.

The compiler generates implicit conversions from each case type into the union automatically. A switch over all declared cases is exhaustive, so there's no discard branch to paper over gaps. Add a case later, and every unhandled switch lights up. Bill Wagner, who authored Microsoft's union-types explainer, notes that unions can carry helper members too. Libraries already shipping union-like types don't need to rewrite syntax, as long as they use the basic constructor-plus-Value shape.

There's also closed hierarchies, a related feature built on a new closed modifier. A closed class limits derivation to its own assembly, giving the compiler enough to check exhaustiveness over a sealed hierarchy. Use unions when combining unrelated types. Reach for closed hierarchies when you actually own the inheritance chain.

Smaller C# 15 additions include collection expression arguments, extension indexers, labeled break and continue, and extended layout support for native interop. The memory-safety work stays in preview and needs opt-in, so don't let it block your planning.

Runtime async

This is the change the runtime folks have been circling for about a decade. Runtime async moves the async/await transformation out of the C# compiler and into the JIT. Rather than the compiler turning each async method into a heap-allocated state machine, it emits a much smaller contract and lets the runtime do the heavy lifting.

The programming model doesn't change. Awaiting still follows the same pattern. Exceptions and cancellation still surface the same way. Microsoft is targeting 100% behavioral compatibility, and the opt-in is a simple feature flag, no new syntax.

The payoff on paper is worth a look. Stack traces get cleaner, showing actual async methods instead of the generated infrastructure stuffed between them. Binaries shrink. In one probe, ten chained Task methods compiled to about 5.2 KB with runtime async versus roughly 10.7 KB with the compiler lowering.

It's opt-in preview, but you don't even need the preview feature switch to try it. The team wants it on by default starting in .NET 12.

The AI stack

AI is the loud theme this year, and rather than dropping one shiny API on you, .NET 11 organizes it into layers.

Microsoft.Extensions.AI gives you standardized abstractions like IChatClient. You compose model access with dependency injection, caching, and OpenTelemetry using patterns you already know. It ships as NuGet packages, so there's no framework migration required to try it.

On top of that sits the Microsoft Agent Framework, or MAF. It adds agents that call tools and hold conversation state, plus workflows to coordinate them. MAF is the open-source merge of AutoGen's agent abstractions and Semantic Kernel's enterprise pieces, and it can expose an agent through an AG-UI endpoint for interactive Blazor UI.

The SDK now ships a built-in dotnet new mcpserver template, so you can start exposing your own functionality without installing a separate package first.

The Blazor AI components remain experimental and stay prerelease throughout .NET 11. Microsoft frames them as a way to try the direction and give feedback, not something you'd put in production tomorrow. Fair enough — that's the kind of thing you'd want labeled honestly rather than smuggled in as stable.

The NuGet ecosystem Microsoft touts now sits on more than 589,000 unique packages. That's a number most people will never meaningfully draw down, but it's the kind of maturity that lets a release lean on third-party code instead of reinventing it.

Everything else worth knowing

Beyond the headline features, there's a lot crammed in. The base class library adds a process API expansion, Zstandard compression, in-memory stream adapters, LINQ FullJoin, new decimal floating-point types, and post-quantum cryptography APIs like ML-KEM and HPKE.

JIT work covers bounds check elimination, switch-expression folding, faster BigMul on x64, FP16 instructions, and new SIMD and Arm SVE2 intrinsics. NativeAOT gets a shared interface dispatch helper plus in-process crash logging on Linux and macOS.

The SDK got faster too. A Native AOT CLI host and a warm MSBuild server are both on by default, shaving startup time off everyday commands. There's a new dotnetup toolchain manager in preview, file-based apps, and container publishing that prefers platform-native runtimes over Docker. ASP.NET Core gains async validation, OpenAPI 3.2 by default, and a CacheView component for static SSR. .NET MAUI now runs on CoreCLR across all platforms. WinForms, WPF, and WinUI get incremental reliability updates.

Here's the honest take, though: most of it is incremental. That's normal for a November .NET release. But union types, runtime async, and a coherent AI stack are the kind of compounding gains that actually change how you work.

Upgrading

You need the .NET 11 SDK. An up-to-date Visual Studio 2026 or VS Code with C# Dev Kit works fine. The smoke test is a couple of lines:

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

Microsoft's four-step plan is pretty standard: update your SDK selection in global.json, retarget frameworks, review the breaking changes, then measure under a real workload. Don't skip the last step. Installing a new SDK doesn't retarget your app on its own, and minimum hardware requirements moved this year, so you'll want more modern instruction sets than before.

If you're on .NET 8 or .NET 9, you have a genuine decision in front of you. Move to .NET 11 for the latest features, or sit on .NET 10 LTS if three years of support matters more than the newest tooling. Either way, the clock started ticking today.

Head here to the .NET 11 SDK download and here to the breaking-changes list before you commit. Sources: Microsoft Learn, the official .NET 11 announcement, and third-party analysis.