.NET 10 Is Out — Update Before November or Lose Support

.NET 10 is out. It ships as Long Term Support, it includes C# 14, and .NET 8 and .NET 9 both lose Microsoft support on November 10, 2026 — that is six weeks from today. If your team is still on either of those runtimes, the upgrade clock is no longer theoretical. The good news: the community consensus is that moving from .NET 8 to .NET 10 is “like a breeze.” The better news: there are genuinely useful features in this release worth upgrading for, not just the security update treadmill.

The November Deadline Is Real

Both .NET 8 (LTS) and .NET 9 (STS) reach end of support on the same date: November 10, 2026. After that, no more security patches. If you are on .NET 9 thinking you have time because it is newer — you do not. .NET 10 is the next LTS and it runs through November 2028. The migration window is now.

The breaking changes are documented and mostly caught by build-time analyzers. A few gotchas to know before you start:

• OpenAPI generator now defaults to 3.1.1. If you use Azure API Management with auto-generated specs, your CI/CD may break. Pin to 3.0.x until APIM supports 3.1.1.
• EF Core’s .Contains() translation changed. Test your queries against staging before rolling to production.
• A failing BackgroundService at startup now takes down all hosted services. Make sure your services handle startup failures gracefully.

Microsoft’s breaking changes documentation for .NET 10 is thorough. Read it before you merge.

dotnet tool exec: The npx You Didn’t Know You Needed

This is the most immediately useful workflow change in .NET 10. dotnet tool exec lets you run any .NET tool without installing it globally or locally first — exactly like npx in Node:

dotnet tool exec dotnet-ef -- database update

For CI/CD pipelines, this is a genuine quality-of-life improvement. No more pre-install steps cluttering your pipeline configuration just to run a one-off migration or code generation tool.

Related: .NET 10 also lets you run .cs files directly without a project file. Reference NuGet packages inline at the top:

#:package Newtonsoft.Json@13.0.3
using Newtonsoft.Json;

var data = JsonConvert.DeserializeObject<MyType>(File.ReadAllText("input.json"));
Console.WriteLine(data?.Name);

That runs with dotnet run script.cs. No .csproj, no dotnet new, no ceremony. It will save you real friction for quick scripts and tooling experiments.

C# 14: Extension Members Change What “Extension” Means

C# has had extension methods since version 3. C# 14 finally extends the concept to what it should have been from the start: you can now add properties, operators, and static members to any type — not just methods. The new extension block groups these together:

extension(string s)
{
    public bool IsNullOrEmpty => string.IsNullOrEmpty(s);
    public string Truncate(int maxLength) => s.Length <= maxLength ? s : s[..maxLength];
}

This is the most significant C# language addition since records in C# 9. The practical effect: you can enrich third-party types and primitives with properties that feel native, without inheritance or wrapper classes.

The field keyword is smaller but immediately useful. It lets you reference the compiler-generated backing field inside a property accessor, cutting a category of boilerplate:

// C# 14
public string Name
{
    get;
    set => field = value?.Trim() ?? string.Empty;
}

Less noise, same intent. The full C# 14 spec is on Microsoft Learn if you want to go deeper.

Performance: The Numbers Actually Hold Up

Performance posts from Microsoft are usually aspirational. The .NET 10 numbers are backed by real benchmarks. A simple aggregation operation that took 19.53 nanoseconds on .NET 9 runs in 6.685 nanoseconds on .NET 10 — a 66% improvement with zero code changes. Real production apps are seeing +11% throughput on aggregation paths from JIT improvements alone.

The changes driving this: better JIT inlining, improved escape analysis that keeps more short-lived allocations on the stack, and more aggressive devirtualization of interface calls on sealed types. AVX10.2 support is now here for workloads doing heavy numeric or graphics computation. The full breakdown is in Microsoft’s performance post — worth skimming for the sections relevant to your workload.

The AI Integration Is Real Now

Microsoft Agent Framework 1.0 — the production-ready merger of AutoGen and Semantic Kernel — ships with native .NET 10 integration through Microsoft.Extensions.AI. You can build a functional multi-agent system in under 20 lines of .NET code with graph-based orchestration, session state, and telemetry built in.

If your team has been reaching for Python because the .NET ecosystem felt behind on AI tooling, that gap has largely closed. The framework supports both Python and .NET with the same API surface, so teams with mixed stacks can converge on one orchestration layer. Native Azure AI Foundry integration is included.

How to Upgrade

Update your NuGet packages to .NET 10-compatible versions before touching the target framework moniker — outdated dependencies are the most common upgrade blocker. Then update your .csproj files to net10.0, run your test suite, and check the breaking changes doc for anything that matches your stack. Do not combine this migration with an EF model redesign or auth rewrite in the same branch — keep the runtime upgrade isolated so you have a clean rollback boundary.

Download .NET 10 and read the full announcement for complete release notes. November 10 is not far off.