.NET 8 and 9 Are Out of Support. Now What?

.NET 8 and 9 Are Out of Support. Now What?
Barret Blake

Barret Blake, Architect

On November 10, 2026, while most of the .NET world was watching the .NET Conf keynote and the launch of .NET 11, two older versions quietly reached the end of the road. .NET 8 and .NET 9 are now out of support. The patches that shipped that same day, 8.0.34 and 9.0.23, are the last ones either version will ever get.

If you’re thinking “wait, didn’t .NET 8 just come out?”, you’re not alone. .NET 8 was an LTS (Long Term Support) release, and a lot of teams standardized on it. .NET 9 was an STS (Standard Term Support) release that many teams skipped entirely. Both of them ended on the same day. And chances are good that at least one app in your portfolio is still running on one of them.

So let’s talk about what “out of support” means for you, how to pick your next version, and how to get there without turning it into a six-month project.

What “Out of Support” Actually Means

Your app didn’t stop working on November 10. It’ll keep running tomorrow, next week, and probably next year. That’s what makes end of support easy to ignore.

Here’s what changed:

  • No more security fixes. Microsoft’s support policy describes end of support as the date when it “no longer provides fixes, updates, or online technical assistance.” When the next vulnerability is found in the runtime, ASP.NET Core, or the base libraries, .NET 8 and 9 won’t get a patch. Affected applications may remain exposed without a supported fix.
  • The ecosystem moves on. Library authors drop out-of-support target frameworks. New versions of the packages you depend on will stop supporting net8.0 and net9.0, and eventually you’ll find yourself stuck on old, unpatched versions of those too.
  • Audits and compliance get harder. If your organization has to answer security questionnaires, pass a SOC 2 audit, or meet a customer’s compliance requirements, “we’re running an unsupported runtime” is not a fun answer.
  • The upgrade gets bigger the longer you wait. Every release you skip is another set of breaking changes you’ll have to absorb all at once.

It’s not just the runtime, either. ASP.NET Core and EF Core ship on the same schedule, so EF Core 8 and 9 and ASP.NET Core 8 and 9 are out of support too.

Start With an Inventory

Before you can plan an upgrade, you need an inventory. It’s usually more than people think. Here are the places to look:

Your project files. Search every .csproj and .props file for target frameworks. In PowerShell:

Get-ChildItem -Recurse -Include *.csproj, *.props |
    Select-String "<TargetFrameworks?>" |
    Select-Object Path, Line

Don’t forget class libraries and test projects. And if you’re multi-targeting with <TargetFrameworks>, check every value in the list.

Your global.json files. These pin the SDK version used to build the solution, which can quietly keep a build on an old SDK long after you’ve moved the projects.

Your machines and build agents. See what’s installed:

dotnet --list-sdks
dotnet --list-runtimes

But remember: --list-runtimes won’t show runtimes bundled into self-contained apps. Those have to be rebuilt and redeployed to pick up a new runtime.

Your containers. Check the FROM lines in your Dockerfiles. mcr.microsoft.com/dotnet/aspnet:8.0 is just as out of support as a net8.0 target framework.

Your pipelines and hosting. CI workflows often pin an SDK version (dotnet-version: '8.0.x' in a GitHub Actions workflow, for example), and app hosting platforms like Azure App Service have their own runtime stack setting that needs to change too.

Make a list. For each app, write down what it targets, where it’s built, and where it runs. That list is your upgrade plan.

The Real Question: .NET 10 or .NET 11?

Once you know what needs to move, you need to decide where it’s moving to. You have two supported choices: .NET 10, the current LTS release, and .NET 11, the brand-new STS release.

The traditional advice used to be simple: production apps go on LTS releases, and STS releases are for teams that want to live on the edge. But take a look at the support dates:

VersionRelease typeReleasedEnd of support
.NET 10LTSNovember 11, 2025November 14, 2028
.NET 11STSNovember 10, 2026November 14, 2028

That’s not a typo. .NET 10 and .NET 11 reach end of support on the same day. LTS releases get three years of support and STS releases now get two, so .NET 11 ends at exactly the same time as the LTS release that came a year before it.

That changes the math. Picking .NET 11 today doesn’t cost you any support time. Whichever one you pick, you’ll be planning your next upgrade to .NET 12, the next expected LTS release, sometime before November 2028.

So how do you choose? Here’s how we’d think about it:

Lean toward .NET 10 if:

  • Your organization has an “LTS only” policy. Plenty of companies do, and they’re not wrong to. One rule that never needs re-litigating has real value.
  • You depend on libraries or platforms that aren’t ready for .NET 11 yet. It’s still early in the release cycle. Most well-maintained packages will support net11.0 quickly, but “most” isn’t “all.” Check your critical dependencies and your hosting platform before you commit.
  • The app is in maintenance mode. If nobody is going to write new features, the new language features and APIs in .NET 11 don’t buy you much. .NET 10 has had a year of patches and ecosystem maturity behind it.

Lean toward .NET 11 if:

  • The app is under active development. You get C# 15, EF Core 11, async validation in ASP.NET Core, and a pile of performance improvements, all with the same end-of-support date.
  • You’re already doing the work. If you’re jumping from .NET 8, you’re absorbing the breaking changes from .NET 9 and 10 anyway. Adding .NET 11 is usually one more set of release notes, not a whole new project.
  • You want to stay on the annual train. Teams that upgrade every November find each upgrade is small. Teams that upgrade every three years find each one is a slog.

If you’re still undecided, .NET 10 is the safe default. But “we’ve always gone LTS” isn’t a good enough reason on its own anymore. Look at the dates, look at your dependencies, and make the call on purpose.

The Upgrade Checklist

Whichever version you pick, the steps are the same. Here’s the checklist we use.

1. Get a Green Baseline

Before you touch anything, make sure the build passes and the tests pass on the version you’re on now. If the test suite is already failing, you won’t be able to tell what the upgrade broke.

If an important area has thin test coverage, this is a good time to consider adding some. Characterization tests with snapshot testing are a quick way to lock in today’s behavior before you change what’s underneath it. And if your integration tests depend on a shared database, consider moving them to Testcontainers so they run the same way on every machine and in CI.

2. Update the SDK and global.json

Install the new SDK on your machine and your build agents, then update global.json:

{
  "sdk": {
    "version": "10.0.100",
    "rollForward": "latestFeature"
  }
}

Use 11.0.100 if you’re going to .NET 11. The rollForward setting lets the SDK roll forward to newer feature bands and patches without editing the file every month.

3. Change the Target Framework in One Place

If your target framework is set in every project file, now is a great time to move it into a Directory.Build.props file at the root of the repo:

<Project>
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
  </PropertyGroup>
</Project>

Then remove <TargetFramework> from the individual projects. The next upgrade becomes a one-line change.

4. Update Your Packages

The Microsoft.* packages that version with the platform, like Microsoft.EntityFrameworkCore.*, Microsoft.AspNetCore.*, and Microsoft.Extensions.*, should move to the major version that matches your target framework. Then check everything else:

dotnet list package --outdated
dotnet list package --vulnerable --include-transitive

If you’re managing versions in every project file, this is another good time to switch to Central Package Management. See Streamlining Your NuGet Package Versions for how to set it up.

5. Read the Breaking Changes for Every Version You’re Crossing

This is the step people skip, and it’s the one that bites. Going from .NET 8 to .NET 11 means reading the breaking changes for .NET 9, .NET 10, and .NET 11, plus the separate ASP.NET Core and EF Core lists for each.

Most of the entries won’t apply to you. But a few common ones that tend to catch teams moving off .NET 8 include:

  • dotnet restore now audits transitive packages (.NET 10). If you build with TreatWarningsAsErrors, a vulnerable package buried three levels deep in your dependency graph can suddenly fail your build.
  • The default .NET container images use Ubuntu (.NET 10). If your Dockerfile installs OS packages or makes assumptions about the base image’s distro, check it.
  • Outside of Central Package Management, a PackageReference without a version now raises an NU1015 error (.NET 10). That usually means a project quietly dropped out of CPM, or a reference was copied in from a repo that uses it. Add the version, or figure out why CPM isn’t applying.
  • IHost.RunAsync and IHost.StopAsync now throw when a BackgroundService fails (.NET 11). If you have hosted services that fail in ways you’ve been quietly ignoring, you won’t be able to ignore them anymore.
  • Restore no longer searches the global packages folder for a higher version (.NET 11). If a restore has only been working because a package happened to be in your local NuGet cache, it can start failing on a clean machine or a build agent. Make sure every package comes from a configured feed.

The full lists are linked in the resources at the end of this post. Budget real time for them.

6. Update Your Containers and Pipelines

Update the FROM lines in your Dockerfiles, the SDK version in your CI workflows, and the runtime stack on your hosting platform. These live outside the solution, so they’re easy to miss, and a perfectly upgraded app that still deploys to an old runtime will fail in very confusing ways.

7. Ship It, and Watch It

Deploy to a test environment first, run your tests, and once it’s in production, watch it for a while. If you’ve got good telemetry in place, you’ll spot changes in error rates, latency, or memory use quickly. If you don’t, OpenTelemetry is worth setting up before the upgrade, not after.

Let the Tooling Do the Grunt Work

If you’ve used the .NET Upgrade Assistant before, note that it’s been officially deprecated. Its replacement is the GitHub Copilot upgrade agent, which assesses your solution, builds a step-by-step upgrade plan, makes the changes, and commits each step so you can review or roll it back. You’ll find it in a few places:

  • Visual Studio: right-click the solution and select Modernize, or use @Modernize in Copilot Chat.
  • VS Code and the GitHub Copilot CLI: use @upgrade.
  • The GitHub Copilot app: pick the Upgrade agent, which also includes the Upgrade Dashboard, a live view of the plan and the work as it happens.

It’s genuinely useful for the tedious parts: updating project files, bumping packages, fixing the obvious API changes, and working through build errors. But treat it the same way we treated our ghost hunters in Exorcising a Haunted Codebase: tools find, agents investigate, humans decide. Review every commit, and pay extra attention to anything that touches behavior rather than syntax. An agent can make the build go green. Only you know whether the app still does the right thing.

What If You Can’t Upgrade Right Away?

Sometimes there’s a real reason an app can’t move yet: a vendor library with no newer version, a platform that hasn’t caught up, or a team that’s already underwater. If that’s you:

  • Write down why, and set a date. “We’ll get to it” is how apps end up on .NET 6 in 2026.
  • Reduce the exposure. Keep the app off the public internet if you can, put it behind a gateway or WAF if you can’t, and keep a close eye on the security advisories for the runtime and your dependencies.
  • Pull out what you can. If one dependency is holding the whole app back, see whether the code that uses it can be isolated behind an interface or moved into its own service so the rest of the app can move forward.

None of these make an unsupported runtime safe. They just buy you time to do the upgrade properly.

Conclusion

End of support isn’t a crisis on day one, but it’s a risk that grows every single day after. The good news is that this year’s choice is easier than usual: .NET 10 and .NET 11 both carry you to November 2028, so you can pick based on your dependencies and how actively the app is being developed, not on support dates.

Take your inventory. Make the call. Work through the checklist. And then put something on the calendar for November 2027, because .NET 12 will be here before you know it.

If you’re facing a pile of apps that need to move and could use a hand, that’s exactly the kind of work we do at NimblePros. Contact us today and let’s talk.

Resources