.NET 11 Released
C# 15 Unions and Upgrade Guide for .NET 8/9 Users
.NET 11 is GA as an STS release supported to Nov 14, 2028. C# 15 unions, .NET 8/9 end of support, upgrade steps, the x86-64-v2 CPU baseline and .NET 10 vs 11.
.NET 11 is the latest major version of .NET, generally available (GA) since November 10, 2026. It is a Standard Term Support (STS) release with two years of support, and C# 15 is the default language version, bringing type-system features such as union types and closed hierarchies. On the same day, .NET 8 and .NET 9 reached end of support, so many teams now need to decide what to move to. This article summarizes the new features, support terms, upgrade steps and breaking changes as confirmed in the official documentation.
Key Points
- .NET 11 went GA on November 10, 2026. It is STS (2 years); the official support policy lists end of support as November 14, 2028
- .NET 8 (LTS) and .NET 9 (STS) reached end of support on November 10, 2026. .NET 10 (LTS) stays supported until November 14, 2028
- C# 15 adds union types, closed hierarchies and collection expression arguments. Installing the SDK does not retarget existing apps, so review the breaking changes, including the new x86/x64 minimum CPU baseline
What Is .NET 11?
.NET 11 is the 2026 release bundling the runtime, libraries, SDK and C# 15. ASP.NET Core 11, EF Core 11 and .NET MAUI were updated at the same time. The announcement notes that .NET MAUI follows its own support policy, separate from the STS/LTS lifecycle, so check the MAUI policy if you use it.
Downloads are on the official .NET 11 download page. Visual Studio 2026, or VS Code with C# Dev Kit, is recommended. If you used a release candidate, the announcement advises moving to the final SDK, runtime and compatible packages and workloads.
Support Terms and Choosing Between LTS and STS
Under the official support policy, even-numbered releases are LTS (three years) and odd-numbered ones are STS (two years). Microsoft states that STS and LTS share the same quality and servicing policies and differ only in support length. You must also install the latest patch to remain supported.
| Version | Type | Release date | End of support | Duration |
|---|---|---|---|---|
| .NET 11 | STS | Nov 10, 2026 | Nov 14, 2028 | 2 years |
| .NET 10 | LTS | Nov 11, 2025 | Nov 14, 2028 | 3 years |
| .NET 9 | STS | Nov 12, 2024 | Nov 10, 2026 | 2 years |
| .NET 8 | LTS | Nov 14, 2023 | Nov 10, 2026 | 3 years |
Note that .NET 11 and .NET 10 both reach end of support on November 14, 2028. Choosing .NET 11 therefore does not buy a later support deadline; the reasons to pick it are new features and performance work.
What End of Support for .NET 8 and .NET 9 Means
.NET 8 and .NET 9 reached end of support on November 10, 2026. After that, patches including security fixes are no longer provided. Apps do not stop working, but newly found vulnerabilities will not be fixed for these versions. The practical choice is .NET 10 (LTS) or .NET 11. For the broader picture, see Preparing for end of support.
Major New Features
C# 15
C# 15 is the default language version for projects targeting net11.0 with the .NET 11 SDK. Except for memory safety, these features do not require LangVersion preview. The examples below follow the syntax shown in the official What's new in C# 15 page.
Union types represent a value that is one of several case types, declared with the union keyword. Implicit conversions from each case type are provided, and the compiler checks that switch expressions are exhaustive.
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,
};Closed hierarchies: applying closed to a class limits direct derivation to its declaring assembly, so the set of direct descendants is fixed at compile time and a switch expression that handles each is exhaustive without a default arm. Derivation is not transitive: a non-closed descendant can still be derived from in other assemblies.
public closed record class GateState;
public record class Closed : GateState;
public record class Open(float Percent) : GateState;
string Describe(GateState state) => state switch
{
Closed => "closed",
Open(var percent) => $"{percent}% open",
};Collection expression arguments let you put a with(...) element first in a collection expression to pass arguments (capacity, comparer, etc.) to the constructor or factory method.
string[] values = ["one", "two", "three"];
// Pass capacity to the List<T> constructor
List<string> names = [with(capacity: values.Length * 2), .. values];
// Pass a comparer to HashSet<T>
HashSet<string> set = [with(StringComparer.OrdinalIgnoreCase), "Hello", "HELLO", "hello"];
// only one element, since the comparer ignores caseExtension indexers let you declare an indexer inside an extension block; because indexers are instance members, the block needs a named receiver parameter. Labeled break and continue let you name an enclosing loop or switch, replacing Boolean flags or goto in nested loops.
public static class SequenceIndexer
{
extension(IEnumerable<int> sequence)
{
public int this[int index] => sequence.ElementAt(index);
}
}
outer: for (int row = 0; row < grid.Height; row++)
{
for (int column = 0; column < grid.Width; column++)
{
if (grid[row, column].IsBlocked) { continue outer; }
if (grid[row, column].IsGoal) { break outer; }
}
}C# 15 also allows non-virtual static interface members on older runtimes. The memory safety work (rethinking how unsafe applies, a multi-release effort) is a preview feature that needs the preview language version, so prefer the stable features for production code.
Runtime and Libraries
- JIT: removal of more redundant bounds checks and branches, better devirtualization and more constant folding
- Native AOT: interface dispatch uses a shared helper, reducing call-site code and improving throughput for interface-heavy workloads
- Hardware: FP16 instructions for Half on supported x64 and Arm64, plus new SIMD lane APIs
- Runtime Async (preview): async suspension and resumption handled by the runtime. For net11.0 no EnablePreviewFeatures is needed; opt in with <Features>runtime-async=on</Features>
- Libraries: Zstandard compression, an expanded Process API, C# union support in System.Text.Json, LINQ FullJoin, and more
ASP.NET Core
- OpenAPI 3.2 is the default, including per-event payloads in server-sent event streams; you can select an earlier version explicitly
- Async validation: new asynchronous DataAnnotations APIs let validators await I/O such as database lookups
- SignalR authentication refresh without reconnecting
- Blazor CacheView caches the rendered output of a component subtree during static SSR
- Unions work wherever ASP.NET Core uses System.Text.Json (JSON bodies in Minimal APIs and MVC), but not for route, query, header or form binding
EF Core 11
EF Core 11 requires .NET 11. It improves GroupBy translation, translates LINQ FullJoin on supporting relational providers, and supports complex types and JSON columns with TPT and TPC inheritance. SQL Server vector indexes and approximate vector search are experimental. Check provider compatibility and the EF Core 11 breaking changes before upgrading.
.NET MAUI
CoreCLR is now the default runtime on all platforms (Apple platforms that disallow JIT use precompiled code and the interpreter). Native AOT is opt-in, with experimental Android support. Microsoft.Maui.Controls.Compatibility no longer ships, so apps referencing it must migrate.
SDK and Tooling
- The Native AOT CLI host and the MSBuild server are enabled by default, so commands like --help run without starting the managed CLI
- File-based apps can span multiple files with #:include
- dotnet nuget add source and dotnet nuget update source gain --min-publish-age-hours, a minimum package publication age setting (the announcement calls it a supplementary control, not a replacement for vulnerability checks)
- Expanded dotnet test options and reproducible container image digests
# Example: ignore packages published less than 72 hours ago (use your own source name)
dotnet nuget update source nuget.org --min-publish-age-hours 72Upgrade Steps
The announcement outlines four steps for existing apps. Installing the SDK alone does not retarget your app.
- 1. Update the SDK in global.json if pinned, and install it on dev machines and build agents
- 2. Update target frameworks to .NET 11 (keep platform-specific suffixes) and update packages and workloads
- 3. Review the breaking changes, including the minimum CPU requirements
- 4. Run tests and measure under a representative workload; validate publishing mode, container base images, native dependencies and deployment hosts
# Check installed SDKs
dotnet --list-sdks
# Create and run a new console app on .NET 11
dotnet new console -n HelloDotnet11 -f net11.0
dotnet run --project HelloDotnet11// global.json (if you pin the SDK)
{
"sdk": {
"version": "<the .NET 11 SDK version you installed>"
}
}<!-- .csproj -->
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net11.0</TargetFramework>
</PropertyGroup>
</Project>Match the global.json version to the .NET 11 SDK shown by dotnet --list-sdks. On machines with several SDKs, dotnet --version shows which one will build the project.
Breaking Changes to Watch
The official breaking changes in .NET 11 page states it is a work in progress and not a complete list. Check the areas your app uses. Key points:
1. Higher minimum hardware. The x86/x64 baseline moves from x86-64-v1 to x86-64-v2, which additionally guarantees CX16, POPCNT, SSE3, SSSE3, SSE4.1 and SSE4.2. Microsoft says this is met by Windows 11 and every x86/x64 CPU officially supported on Windows 10, and that the last older chips went out of support around 2013. On unsupported CPUs, .NET may fail to start with a message like "The current CPU is missing one or more of the baseline instruction sets." The Arm64 minimum is unchanged, but ReadyToRun targets were updated, so some devices fall back to JIT with extra startup overhead.
2. .NET MAUI changes. Mobile moves from Mono to CoreCLR, so Mono embedding APIs and project properties no longer apply. Android x86 is unsupported and the minimum Android API level is raised to 24.
3. SDK and library behavior changes. Examples include NativeAOT CLI handling on by default, the default scope of named mutexes on Unix, Math.Round results, aggregated exceptions on DI scope disposal, and IHost.RunAsync throwing when a BackgroundService fails. They are classified as behavioral changes, so verify with tests.
Stay on .NET 10 LTS or Move to .NET 11?
Both end support on November 14, 2028, so "longer support" is not a reason to prefer .NET 10. The deciding factors are whether you need the new features and how much validation effort you can spend.
| Situation | Suggested choice | Reason |
|---|---|---|
| On .NET 8/9 and need a target now | .NET 10 (LTS) | Already available; same end-of-support date as .NET 11 (Nov 14, 2028) |
| Want C# 15 unions or closed hierarchies | .NET 11 | C# 15 is the default language version of the .NET 11 SDK |
| Need ASP.NET Core OpenAPI 3.2 or EF Core 11 features | .NET 11 | EF Core 11 requires .NET 11 |
| Older x86/x64 CPUs remain in servers or devices | Check hardware first | .NET 11 may not start below x86-64-v2 |
| Running MAUI mobile apps | Review MAUI policy and breaking changes first | CoreCLR switch and Android API 24 minimum |
| Little capacity for validation | Stay on .NET 10 | Same end date with the fewest changes |
A staged path also works: move from .NET 8/9 to .NET 10 first to resolve the end-of-support gap, then adopt .NET 11 project by project where the new features matter. For handling server OS and middleware end of support, see Windows Server 2016 end of support.
FAQ
Is .NET 11 an LTS release?
No. It is STS with two years of support, and the official policy lists end of support as November 14, 2028, the same date as .NET 10 (LTS).
Will .NET 8 or .NET 9 apps stop working right away?
No. But support ended on November 10, 2026, so security patches are no longer provided. Plan a move to .NET 10 or .NET 11.
Does installing the SDK make existing apps run on .NET 11?
No. Update the TargetFramework to net11.0, update packages and workloads, review breaking changes and run your tests.
Will .NET 11 run on older servers?
On x86/x64 the baseline is now x86-64-v2, and CPUs below it may fail to start. Microsoft says Windows 11 and officially supported Windows 10 CPUs meet it. Verify your hardware before migrating.
Related free tools (no sign-up, instant results)
Feel free to contact us
Contact Us