.NET 8 and .NET 9 Lose Support on the Same Day, 10 November. Your Inventory Is the Hard Part.
A 24-month window for short-term releases means two runtimes expire together. The upgrade is one line; finding every pin is not.
Microsoft will stop servicing both .NET 8 and .NET 9 on 10 November 2026, according to the .NET team's end-of-support announcement. That is six days from today. Nothing crashes on the 10th. Your services keep serving requests, and the first sign that anything changed will be the next vulnerability disclosure that gets a fix for .NET 10 and nothing for the runtime you are on.
The upgrade itself is mostly a one-line change in a project file. The reason it still takes teams weeks is that a .NET version is not recorded in one place. This piece is about the other places, and about why two runtimes expiring on the same day is a pattern rather than a coincidence.
Why .NET 8 and .NET 9 expire together
.NET 8 is a long-term support release, shipped in November 2023 with 36 months of support. .NET 9 is a standard-term support release, shipped in November 2024. Standard-term releases used to get 18 months. Microsoft extended that to 24, which moves the end date of .NET 9 to the same Patch Tuesday that closes out .NET 8.
The arithmetic is simple. Annual November releases, 36 months for the even-numbered LTS version and 24 months for the odd-numbered one means that an LTS and the standard-term release that follows it expire together. The next pair, .NET 10 and .NET 11, lines up the same way in November 2028. Teams that used the short-term release as a comfortable middle rung no longer have one: both exits are the same day.
| Release | Track | Released | Support ends |
|---|---|---|---|
| .NET 8 | LTS (36 months) | November 2023 | 10 November 2026 |
| .NET 9 | STS (24 months) | November 2024 | 10 November 2026 |
| .NET 10 | LTS | November 2025 | November 2028 |
| .NET 11 | STS, expected November 2026 | Not yet released at time of writing | Not yet announced |
What actually stops on 10 November
Microsoft says existing apps keep running. Three things end: new security updates, servicing fixes and technical support. The date is also a Patch Tuesday, so each version may receive one last update that day, but only if there is a known critical issue. Do not plan around a bonus release.
Visual Studio is the second-order effect. Microsoft says a future servicing update for Visual Studio 2022 will mark the .NET 8 and .NET 9 components as out of support, and it points to a "remove out of support components" option. Microsoft states that existing installations are not affected, though at least one reader on the announcement disputes that. Check your own installation before you assume either way.
The announcement does not cover container images or managed hosting. If your services run on a cloud platform that offers .NET 8 or 9 as a selectable runtime, read that platform's own lifecycle page. Platform retirement schedules are set by the platform, and they do not always match the upstream date.
The one-line change and the six places that fight it
Microsoft's guidance is to set TargetFramework to net10.0 in the project file, then update development and hosting environments. That first half is trivial. The second half is where upgrades stall, because the version is also written into places that no build will warn you about.
| Surface | What to look for | Why it is missed |
|---|---|---|
| Project files and props | TargetFramework, TargetFrameworks, Directory.Build.props | Multi-targeting keeps net8.0 alive after everyone moved on |
| global.json | Pinned SDK version | Overrides the SDK installed on the build machine |
| Dockerfiles | sdk, aspnet and runtime image tags | Tag is a string; no compiler checks it |
| CI pipelines | setup-dotnet version, build agent images | Lives in a different repo from the code |
| Hosts and functions | Installed runtimes, platform runtime selector | Set once in a console and forgotten |
| NuGet dependencies | Packages that only target netcoreapp or net8.0 | Resolve fine, then block the move |
A first pass can be done with a few greps across every repository you own. It will not be complete, but it will tell you how big the problem is before anyone starts estimating.
# Run from a directory that contains all your repos
grep -rnE "net(8|9)\.0" --include=*.csproj --include=*.props --include=*.targets .
grep -rn "\"version\"" --include=global.json .
grep -rnE "dotnet/(sdk|aspnet|runtime)(-deps)?:(8|9)" --include=Dockerfile* --include=*.yml --include=*.yaml .
grep -rnE "dotnet-version:? *['\"]?(8|9)" --include=*.yml --include=*.yaml .
# On a host, list what is installed
dotnet --list-runtimes | grep -E "Microsoft\.(AspNetCore|NETCore)\.App (8|9)\."Treat the output as a to-do list, not a verdict. A match in a Dockerfile for a service that was decommissioned last year is noise. A miss in a repository you forgot belonged to your team is the one that matters, so cross-check the list against whatever your organisation uses as a service catalogue.
Dependencies decide the timeline
Most of the surprises arrive from packages, not your own code. A library that targets only an older framework can still resolve on a newer runtime in many cases, but not all, and an abandoned package that has not shipped a release in two years is a decision you now have to make: replace it, fork it, or carry the exception.
Microsoft also publishes a breaking-changes list for each release, and recommends reading the one for .NET 10 before you start. Reading it is cheap. The expensive part is the behaviour change that your tests do not cover, which is why the order below matters.
“Upgrade your test coverage before you upgrade your runtime.”
If a service has thin tests, the upgrade work is test-writing work with a version bump at the end. Budget accordingly, and say so in the ticket.
A rollout order that limits the blast radius
- Stage 1: libraries. Add net10.0 as an additional target to shared packages, keep the old target for one release, and publish. Consumers can then move on their own schedule.
- Stage 2: CI. Add a net10.0 job beside the existing one and let it run green for a week before it becomes required.
- Stage 3: lowest-risk services first. Internal tools and batch jobs surface the behaviour changes that matter, without customers watching.
- Stage 4: the revenue path. By now the breaking-change list has been tested against real code rather than read about.
- Stage 5: remove the old target and the old images, so that nothing can quietly roll back onto an unsupported base.
If a service cannot finish by 10 November, that is normal. What matters is that the exception is written down: the service, the reason, the owner and the date by which it will be reviewed. An undated exception is a vulnerability with a good excuse.
The part that repeats every year
A support deadline now lands in the same fortnight as a new release. .NET 11 is expected in November 2026, which means the clock for the next pair starts immediately. A small recurring job helps more than a one-off scramble: a quarterly report from the greps above, filed against a calendar of vendor end-of-life dates, turns a deadline into a routine.
Runtime lifecycles are now short enough that a version pin is a liability with an expiry date. The teams that handle it well in 2027 will be the ones that wrote the inventory down this week.
Frequently asked questions
Related reading
Postgres 14 Reaches End of Life on 12 November. On RDS, the Date That Bills You Is 1 March 2027.
The Postgres community stops patching version 14 on 12 November 2026. Amazon RDS keeps it in standard support until 28 February 2027, then charges. Here is how to read the gap.
OpenAI Reports 948 Linux Privilege-Escalation Findings. The Number Is a Review Queue, Not Your Exposure.
OpenAI says an unreleased cyber model produced 948 Linux kernel privilege-escalation results for about $1.2M. Here is what that number measures, and what to check on your own fleet.
Auth0 Rules and Hooks Are Read-Only. Which End-of-Life Date Applies Depends on Whose Page You Read.
Some trackers list 18 November 2026 as the day Auth0 Rules and Hooks stop. Auth0's docs give 30 April 2027 for Hooks and 31 January 2028 for Rules. Here is what to check and how to migrate.