
Microsoft shipped .NET 11 on November 10, 2026, opening the free virtual .NET Conf 2026 with the platform's annual major release. The headline is C# 15, which becomes the default language version for projects targeting .NET 11, and its headline feature is union types — a way to say, in the type system itself, that a value is one of a fixed set of possibilities, with the compiler checking that your code handles every one of them.
That is the feature most developers will actually feel. But the release also carries a deadline that matters more than any single feature: .NET 8 and .NET 9 reached end of support on the very same day. If your production services still run on either, the security patches stop now.
.NET 11 is a Standard Term Support (STS) release, which under Microsoft's current policy means two years of support — through November 2028. It is not the long-term support release. That role still belongs to .NET 10, which remains supported through November 14, 2028. The two tracks differ only in support length, not in quality or servicing policy, according to Microsoft's announcement.
| Version | Support type | Supported until | Status |
|---|---|---|---|
| .NET 8 | LTS | November 10, 2026 | End of support |
| .NET 9 | STS | November 10, 2026 | End of support |
| .NET 10 | LTS | November 14, 2028 | Current LTS |
| .NET 11 | STS | November 2028 | Current, newest features |
The practical reading: if you run long-lived services and upgrade rarely, stay on .NET 10. If you want the newest language features, .NET 11 is the release to move to.
C# has always made it awkward to express "this operation returns either a success or a specific kind of failure." Developers reached for exceptions, nullable returns, or one-off result classes, and the compiler could never check that every outcome was handled. Union types fix that at the language level. You declare a value as one of several case types with the union keyword, and the compiler enforces exhaustive switch expressions over the cases.
public union LookupResult(Product, ProductNotFound);
public string Describe(LookupResult result) => result switch
{
Product p => $"Found: {p.Name}",
ProductNotFound => "No such product",
};
If someone later adds a third case to the union, every switch that handles it fails to compile until it is updated. That is the whole point: a class of runtime bugs — the forgotten branch — becomes a build error. Microsoft's own announcement uses exactly this product-lookup shape as its example.
One rough edge worth knowing: ASP.NET Core serializes a union as the active case's plain JSON object, with no type field, so when two cases share the same JSON shape you need to configure a classifier for deserialization to tell them apart. Prototype it in an API boundary before committing to it there.
Union types get the attention, but C# 15 ships five more additions, and two of them are genuinely useful in everyday code:
closed restricts direct inheritance to its declaring assembly, so the compiler can reason exhaustively about the hierarchy — the same way it does for union cases.this[...] access to a type you don't own. If the type already has its own indexer, the type's indexer wins.break and continue. Label a loop and break or continue to it by name, which cleans up nested-loop code that previously needed flags or helper methods.unsafe model ships as a preview feature. It is not final — treat it as something to watch, not to adopt yet.None of these require a <LangVersion>preview</LangVersion> flag anymore, except memory safety. Delete the preview flag from your project file and C# 15 is simply what you get on .NET 11.
The most visible tooling change is the Native AOT CLI host. The .NET 11 SDK runs a Native AOT-compiled dotnet host by default, and keeps the background MSBuild server warm between invocations, so everyday commands start noticeably faster. This sounds minor in a release note and then saves you a few seconds dozens of times a day.
Under the hood, the runtime continues Microsoft's yearly performance work: faster interface dispatch in Native AOT, cross-lane operations for vectors, and smaller Native AOT SDK images. Runtime Async — a rework that removes async state-machine overhead — is also part of this release's story, though it remains a preview feature for application code, so don't plan an architecture around it yet.
The SDK also leans into the agent era: there is a built-in dotnet new mcpserver template for scaffolding a Model Context Protocol server, and a preview dotnetup toolchain manager. If you want background on what MCP servers are and why every platform is suddenly shipping templates for them, our explainer on MCP, the USB-C of AI covers the protocol, and what an AI agent actually is covers the agentic side.
The web and data stack got its share too:
VECTOR_SEARCH() into LINQ, with HasVectorIndex() for creating vector indexes through migrations and a VectorSearch() extension method that returns results ordered by vector distance, optionally with approximate search over the index. One detail that matters for existing apps: vector properties are no longer loaded by default when materializing entities, which Microsoft's documentation says can be dramatically faster on real workloads. Note that the SQL Server vector index APIs are still flagged experimental, so expect them to shift.FullJoin operator, which keeps rows from both input collections and matches them when keys are equal.Taken together, the theme of the release is consolidation rather than revolution: fewer sidecars (vector search moves into the database you already have), fewer ceremony layers (union types replace hand-rolled result types), and a faster feedback loop (the CLI and the build server).
The release was picked up quickly on LINUX DO, China's large developer forum, where the announcement thread drew a mix of enthusiasm and skepticism. The praise centered on union types and compiler-checked exhaustiveness; the pushback fell into three buckets: several language ideas resemble features that already exist in other languages, Runtime Async still needs manual enabling, and a meaningful share of developers said they will wait for the next LTS release rather than adopt an STS version.
That last reaction is worth taking seriously. The forum's read is essentially the same as the support-table read above: .NET 11 is a good release to learn from and to adopt if you track the newest features, but the conservative production choice remains .NET 10 until .NET 12 arrives in late 2027.
A short decision guide:
Install the SDK from Microsoft's official download page or get.dot.net/11, retarget your projects to net11.0, remove any <LangVersion>preview</LangVersion> entries, and run your test suite. For most projects the upgrade is uneventful; the breaking changes are tracked in Microsoft's C# 15 breaking-changes article if you want to check before you start.
.NET 11 is not a release that asks you to rethink how you build software. It removes small, daily frictions — a faster CLI, a result type the compiler can check, vector search without a sidecar — and pairs them with a hard deadline for anyone still on .NET 8 or 9. The language finally has a first-class way to say "one of these things," and the compiler will now hold you to it. That, plus the support calendar, is the whole story.
Sources: Microsoft's official announcement, Announcing .NET 11; Microsoft Learn, What's new in C# 15 and What's New in EF Core 11; community discussion on LINUX DO.