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

> .NET 8 and .NET 9 reached end of support on November 10, 2026. Here's what that means, how to choose between .NET 10 LTS and .NET 11, and a practical checklist for getting your apps upgraded.

- URL: https://blog.nimblepros.com/blogs/dotnet-8-9-end-of-support/
- Author: [Barret Blake](https://blog.nimblepros.com/authors/barretblake/)
- Published: 2026-11-17
- Categories: [Software Development](https://blog.nimblepros.com/categories/software-development/)
- Publisher: [NimblePros](https://blog.nimblepros.com/)

---

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:

```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:

```bash
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:

| Version | Release type | Released | End of support |
|---|---|---|---|
| .NET 10 | LTS | November 11, 2025 | November 14, 2028 |
| .NET 11 | STS | November 10, 2026 | November 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](../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](../testcontainers-integration-testing/) 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`:

```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:

```xml
<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:

```bash
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](../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](../otel/) 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](../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](https://nimblepros.com/talk-to-us-1) and let's talk.

## Resources

- [.NET and .NET Core official support policy](https://dotnet.microsoft.com/platform/support/policy/dotnet-core)
- [Microsoft Learn: Breaking changes in .NET 9](https://learn.microsoft.com/dotnet/core/compatibility/9.0)
- [Microsoft Learn: Breaking changes in .NET 10](https://learn.microsoft.com/dotnet/core/compatibility/10)
- [Microsoft Learn: Breaking changes in .NET 11](https://learn.microsoft.com/dotnet/core/compatibility/11)
- [Microsoft Learn: Breaking changes in ASP.NET Core 10](https://learn.microsoft.com/aspnet/core/breaking-changes/10/overview)
- [Microsoft Learn: Breaking changes in EF Core 10](https://learn.microsoft.com/ef/core/what-is-new/ef-core-10.0/breaking-changes)
- [Microsoft Learn: GitHub Copilot upgrade overview](https://learn.microsoft.com/dotnet/core/porting/github-copilot-upgrade/overview)
- [Microsoft Learn: .NET Upgrade Assistant overview (deprecated)](https://learn.microsoft.com/dotnet/core/porting/upgrade-assistant-overview)
- [Characterization Tests With Snapshot Testing](../characterization-tests-with-snapshot-testing/)
- [Testcontainers in .NET: The Integration Testing Stack That Works Everywhere](../testcontainers-integration-testing/)
- [Streamlining Your NuGet Package Versions](../streamlining-your-nuget-package-versions/)
- [OTEL - An Introduction To OpenTelemetry](../otel/)
- [Exorcising a Haunted Codebase: Banishing Code Demons with AI Agents](../exorcising-a-haunted-codebase/)
