.NET 11 Launches With C# 15, Union Types, Faster JIT

Microsoft shipped .NET 11 on November 10, 2026, pairing the release with C# 15, F# 11, a long list of JIT and runtime performance gains, and built-in support for Model Context Protocol (MCP) servers and AI agents. The release lands on the same day .NET 8 and .NET 9 reach end of support, pushing many enterprise teams toward an upgrade whether they were ready or not.

What Shipped on November 10

.NET 11 is Microsoft's twelfth annual major release of the modern .NET line, announced on the company's official .NET Blog alongside the opening of .NET Conf 2026, which ran November 10-13. The general-availability build is runtime and SDK version 11.0.0/11.0.100, and Visual Studio 18.12.0 is the first Visual Studio release to include it. The announcement post frames the release around three themes: language features aimed at reducing boilerplate and runtime errors, "hundreds" of performance optimizations across the JIT and base class libraries, and first-party building blocks for AI agents and tool-calling.

Unlike odd-numbered .NET releases in past cycles, which historically got 18 months of support, Microsoft confirmed .NET 11 (and .NET 9 before it) now receives a full 24 months as a Standard Term Support release — the company says STS builds now carry "the same quality and servicing" commitments as its Long Term Support releases, just for a shorter window.

C# 15: Union Types and Closed Hierarchies

C# 15 is the default language version for any project that targets net11.0, and it's the most visible change for most developers. The headline feature is discriminated-union-style union types: a value can be declared as one of a fixed set of case types, and the compiler performs exhaustiveness checking when that value is handled in a switch expression — a pattern C# developers have long emulated with sealed class hierarchies or third-party libraries.

Paired with unions is a new closed modifier for classes. A closed class can only be derived from within the assembly that declares it, which lets the compiler reason about — and warn on incomplete handling of — the full set of possible subtypes in pattern matching, similar to sealed hierarchies in F# or Kotlin.

Other C# 15 additions called out in the announcement include collection-expression arguments (for example, passing a comparer inline when building a collection literal), extension indexers, and labeled break/continue statements for clearer control flow in nested loops. A broader memory-safety initiative for the language remains in preview and isn't enabled by default.

F# 11 Trims Memory and Allocations

F# 11 ships alongside C# 15 with a narrower but still meaningful set of changes: the compiler itself uses less memory during builds, and common operations in the FSharp.Core collection library allocate less. The release also adds new ways to bound concurrent asynchronous work, aimed at F# codebases that fan out many async operations at once and want backpressure without hand-rolled throttling.

Runtime and JIT Performance

.NET's performance engineering lead, Stephen Toub, published a companion deep-dive, "Performance Improvements in .NET 11," on the .NET Blog detailing the release's runtime and library-level work. Per Microsoft's own posts, the release includes further JIT improvements such as additional bounds-check elimination and better devirtualization of generic virtual method calls, continuing a multi-release trend of shrinking the gap between virtual and non-virtual call costs.

Native AOT compiled apps get a shared helper for interface dispatch, trimming code size and improving consistency across AOT-compiled binaries. .NET 11 also adds FP16 (half-precision floating point) instruction support on both x64 and Arm64, useful for machine-learning and graphics workloads that don't need full 32-bit precision. Separately, in-process crash report logging — previously limited to mobile targets — now works on Linux and macOS server workloads too, which should make production crash triage easier for teams running .NET services outside Windows.

A preview-only "Runtime Async" feature, enabled via an MSBuild <Features>runtime-async=on</Features> flag rather than the general preview-features switch, previews changes to how the runtime schedules async continuations — an early look at work that could reshape async performance in a future release.

AI Building Blocks Land in the Box

.NET 11 is the first release to bundle first-party AI plumbing rather than leaving it entirely to NuGet add-ons. A new dotnet new mcpserver template scaffolds a Model Context Protocol server built on the official MCP C# SDK, letting .NET developers expose tools to AI assistants without hand-writing the protocol layer. Alongside it, Microsoft.Extensions.AI ships abstractions such as IChatClient and IEmbeddingGenerator meant to standardize how .NET apps talk to different model providers, and the Microsoft Agent Framework adds primitives for agents with tools and persisted state, plus multi-step workflows (its AG-UI hosting integration remains prerelease). Experimental, prerelease Blazor AI components round out the set, though Microsoft is explicit that those stay experimental for the whole .NET 11 cycle.

None of this requires buying into a specific AI product — the abstractions are designed to be provider-agnostic — but it does mean MCP support, which only became a mainstream integration point for coding tools and IDEs over the past year or so, is now a dotnet new command away rather than a manual protocol implementation.

SDK and Tooling Changes

Several tooling defaults flip in this release: the SDK enables a Native AOT CLI host and a "warm" MSBuild server by default, both aimed at cutting command-line startup latency for everyday dotnet build/dotnet run workflows. dotnet watch gains Aspire app-host integration, and dotnet test adds run-level timeouts and failure limits for teams using the Microsoft.Testing.Platform runner — handy for CI pipelines that need to fail fast on a hung test run rather than waiting out the full job timeout.

NuGet can now enforce a minimum package publication age before a dependency is eligible to be pulled into a build, a supply-chain-adjacent guardrail against newly published, potentially malicious package versions being adopted automatically. That lands in a year where open-source registries generally have had a rough run with supply-chain abuse — Pandromeda covered a large npm-ecosystem credential-harvesting campaign earlier this year, which was unrelated to .NET but part of the same broader pattern NuGet's new setting is meant to blunt.

Preview-stage tooling previewed alongside the release includes dotnetup, a standalone SDK and runtime version manager; an experimental .NET MAUI "DevFlow"; and a ".NET Upgrade" canvas experience for planning multi-step framework migrations. None of these are enabled by default in the GA build.

Visual Studio 18.12.0 is the first VS release built to include the .NET 11 SDK — the same Visual Studio update Pandromeda covered when Microsoft dropped the Live Share collaboration feature from the IDE. Teams updating Visual Studio to get .NET 11 support will pick up that change at the same time.

Security Fixes Bundled With the Release

Alongside new features, the .NET 11.0.0 release notes published on GitHub list roughly twenty CVE fixes bundled into the initial release, spanning denial-of-service, elevation-of-privilege, and remote-code-execution issues across ASP.NET Core, the .NET runtime, and Visual Studio. Microsoft's official .NET Docker images were updated to match. The release notes don't break out severity scores publicly beyond the CVE identifiers, so teams running .NET in production should treat the GA build as a standard "patch Tuesday"-aligned security update in addition to a feature release — a cadence that has become routine for .NET's November ship dates, much as it has for other ecosystems that occasionally need emergency out-of-band fixes, like the inactive-repository Dependabot change Pandromeda reported on GitHub rolling out next month.

Support Lifecycle: Two Clocks Reset at Once

November 10, 2026 is a hard deadline for two older releases, not just a launch date for the new one. Microsoft's support policy page confirms .NET 8 (an LTS release first shipped November 14, 2023) and .NET 9 (STS, shipped November 12, 2024) both reached end of support that day — no further security patches for either runtime. .NET 10, released a year earlier as an LTS build, remains supported through November 2028 for teams not ready to move to .NET 11 immediately.

Apps still running on .NET 8 or .NET 9 won't stop working on their own, but they'll no longer receive security or non-security fixes from Microsoft, which puts them outside compliance for many regulated environments. Teams that can't move straight to .NET 11 have .NET 10's remaining two years of LTS coverage as a fallback, rather than jumping two major versions at once.

Breaking Changes and Migration Notes

Microsoft's own guidance is that installing the .NET 11 SDK doesn't retarget existing applications — projects keep building against whatever target framework and global.json-pinned SDK version they already specify until a developer changes it. For projects that do move, the release notes flag several concrete breaks: EF Core 11 requires .NET 11 and has its own breaking-change list that provider authors (SQL Server, PostgreSQL, SQLite drivers, etc.) need to catch up with; .NET MAUI now uses CoreCLR by default and no longer ships the optional Microsoft.Maui.Controls.Compatibility package, so apps still referencing it need to migrate before upgrading; and Blazor's "pause circuit on inactive tab" behavior now needs an extra package reference and explicit configuration rather than working out of the box.

The new language features carry their own caveats: union-type JSON (de)serialization needs an explicit classifier when multiple case types share an identical JSON shape, and union support doesn't currently extend to ASP.NET Core's route, query, header, or form-model binding. F#'s equivalent union JSON support relies on reflection and is explicitly incompatible with source generation, trimming, or Native AOT publishing — a limitation worth knowing before planning an AOT-published F# service around the new types. Teams that have been tracking .NET 11 through its release-candidate builds should move to the final SDK and matching NuGet package versions rather than staying on an RC.

What's Next

With .NET 11 out the door, expect the usual early-cycle churn: a steady stream of .1-style servicing updates addressing day-one bugs, provider and tooling ecosystems (EF Core providers, Azure SDKs, third-party ORMs) catching up to the new target framework, and conference talks from .NET Conf 2026 landing on Microsoft's YouTube channel over the following weeks. The bigger open question is adoption speed among enterprises still mid-migration off .NET 8 or .NET 9 — Microsoft's own messaging leans on .NET 10's LTS status as the "safe" landing spot for teams not ready to adopt union types and the other C# 15 changes on day one. Watch for how quickly EF Core, ASP.NET Core third-party middleware, and Native AOT-sensitive libraries publish .NET 11-compatible releases, since that ecosystem lag is typically what determines how fast a new .NET version moves from "available" to "default" in production.

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 Felix MoreauAll Software & Guides coverage