.NET 10 LTS: What Ships Today, What’s Still Pending

.NET 10 LTS is here, and it matters. The primary keyword for this discussion—.NET 10 LTS—signals three years of stability, performance gains across the runtime and libraries, and meaningful language updates (hello, C# 14). If you run APIs, services, or desktop apps at scale, this is the release to plan around now—not six months from now when fire drills start.

What’s actually GA in .NET 10 LTS right now?

As of November 11, 2025, .NET 10 is a Long‑Term Support release with security and servicing updates through November 2028. The runtime and SDKs are available, and the language teams shipped C# 14 and F# 10 with tangible, everyday benefits. You don’t need to learn exotic features to see wins; you’ll feel it in cleaner property declarations, fewer allocations, and simpler async/collection code.

Highlights we’re already seeing in real projects:

• Performance: JIT and runtime optimizations slash allocations and improve inlining and devirtualization. NativeAOT produces smaller, faster binaries where it fits (think CLIs, microservices with constrained reflection needs).
• C# 14 quality‑of‑life: Field‑backed properties reduce boilerplate. Extension members get more capable, and collection/Span improvements make high‑throughput code less painful.
• Libraries: Safer JSON defaults (e.g., detection for duplicate properties), upgraded cryptography and TLS, and better WebSocket/HTTP pipelines.
• Security posture: A continued push on request handling, serialization hardening, and modern cipher suites.

That’s the “ship today” picture for local builds, CI, and container images you control. But there’s a catch…

So… why can’t I deploy to Azure App Service yet?

Because big cloud platforms roll out new runtimes gradually. If you open the Azure App Service runtime stack list this week, you may still see “.NET 10 LTS (Preview)” in some regions. That label isn’t cosmetic; it means region‑by‑region validation is still in motion. When the switch flips to GA across your regions, you’ll be able to target the managed runtime without workarounds.

Until then, you’ve got three practical options that work today for production:

• Publish self‑contained: Build --self-contained true and deploy your app with the .NET 10 runtime inside the artifact. App Service can run it even if the platform runtime isn’t GA.
• Use containers: Ship a pinned .NET 10 image (or distroless) and deploy via Web App for Containers. You control the runtime version, patches, and startup.
• Stay on .NET 8/9 for a beat: If you’re mid‑sprint and can’t change deployment models, continue shipping on a supported version and schedule migration for the next sprint boundary.

What about Azure Functions? The isolated worker model already supports .NET 10; the in‑process model doesn’t. If you’re still in‑process and want .NET 10, move to isolated—preferably alongside your upgrade so you touch code once.

Support windows that change your upgrade math

One strategic change got less attention than it deserves: Standard Term Support (STS) releases now have 24 months of support (starting with .NET 9). Translation: .NET 9 and .NET 8 both reach end of support on November 10, 2026, while .NET 10 LTS runs through November 2028. This alignment removes the old six‑month cliff that made some teams avoid STS entirely. It also gives you breathing room to plan: upgrade to .NET 10 once, then hold for three years.

If you’re on .NET 6 or 7, you’re already out of support. If you’re on .NET 8 or 9, you’ve got a defined runway—but don’t procrastinate. The costliest upgrades are the rushed ones.

Security: the quiet reason to move sooner

Performance headlines are fun, but security keeps the lights on. This fall included a critical fix in the web stack that reminded folks how complex HTTP handling can be at high throughput. Teams that patch promptly and keep moving to supported trains had an easier week. The lesson isn’t “panic and jump to the newest.” It’s “avoid dead branches and keep your production baseline upgradable.” .NET 10 LTS gives you that baseline for three years.

The .NET 10 LTS 14‑Day Upgrade Framework

Here’s a practical, no‑drama plan we use with clients. You can adapt it for a single service or a 50‑service estate.

Day 1–2: Inventory and risk map

List every app targeting .NET ≤9. Note hosting model (VM, App Service, container), deployment type (framework‑dependent vs self‑contained), and production region(s). Flag anything with tight memory budgets, heavy reflection, dynamic proxies, or source generators. Write down your top three unknowns—these become the spike tasks.

Day 3–4: Tooling and baselines

Install the .NET 10 SDK on CI and dev machines. Spin a throwaway branch for each app and run builds with TargetFramework=net10.0. Capture baseline benchmarks (startup, a hot endpoint, and a serializing endpoint). If you don’t have microbenchmarks, create a thin console harness that hits your hottest code paths. Commit the numbers.

Day 5–6: Language and runtime gotchas

Enable C# 14 in one service first. Compile and fix: nullable warnings, analyzer recommendations, and any missing binding redirects. Check AOT compatibility if you plan to use NativeAOT: reflection, dynamic codegen, and some DI patterns need tweaks. Where AOT isn’t ready, don’t force it—use the JIT and keep moving.

Day 7: “One descopes” marriage

Pick one small service and take it end‑to‑end: build as self‑contained on App Service or as a container image if you’re using Web App for Containers/Kubernetes. Wire a staging slot, run smoke tests, then hammer with a traffic replay for 30 minutes. If Azure still shows .NET 10 as Preview in your region, this approach bypasses it.

Day 8–9: Dependency pass

Bump packages that are net10‑aware. Pay special attention to logging/metrics (Serilog, OpenTelemetry), JSON (System.Text.Json extensions, converters), HTTP clients, and authentication libraries. Most upgrades are painless, but this is where reflection and source generator quirks surface. Bake unit tests and a quick integration test into the CI matrix for net8.0 and net10.0 until you cut over.

Day 10: Performance budget check

Rerun the same three benchmarks and compare to your Day 3 baselines. NativeAOT services should show notable cold‑start improvements; JIT services should trend flat or better. Investigate regressions over 5%: often it’s a package update, JSON converter, or a missed Tiered JIT setting. Don’t chase micro‑regressions when your P95/P99 didn’t change.

Day 11–12: Production pilot

Ship one service behind a feature flag or to a canary ring. Watch CPU, memory, GC pauses, HTTP 5xx, and latency percentiles. If you use App Service, set WEBSITE_SWAP_WARMUP_PING_PATH for smoother swaps and run‑from‑package to simplify rollbacks. If you use Kubernetes, pin the runtime image tag and keep a green rollback image in the same registry.

Day 13–14: Rollout and documentation

Promote to additional rings, then document the path so the next five services go twice as fast. Capture anything Azure‑specific you needed (startup command tweaks, certificate chains, managed identity scopes). Close the loop: add monthly runtime patch windows to your ops calendar so you keep getting fixes without drama.

Azure App Service: quick workarounds that actually work

If the managed .NET 10 runtime is still marked Preview in your region, use one of these patterns and keep shipping:

• Self‑contained framework‑dependent fallbacks: Build self‑contained for production, but keep framework‑dependent builds for dev/test to speed inner loops.
• Containerize a subset: Start with your stateless, low‑risk services. Use an LTS base image, add your app, pin minor/patch tags, and automate image rebuilds on Patch Tuesday.
• Don’t mix deployment models per app: Pick self‑contained or container for a service and standardize. Mixing creates hidden entropy.

Got an App Service plus Functions estate? Move Functions to the isolated worker model if you want .NET 10 now. In‑process is fine for .NET 8/9, but it won’t take you to 10.

People also ask: fast answers

Should I skip .NET 9 and go straight to .NET 10 LTS?

Yes, if you’re on .NET 8 or older and you haven’t already moved to 9, going directly to .NET 10 LTS is the sane call. It reduces total migrations and locks three years of support.

Will C# 14 break my code?

C# is designed to be backward compatible. Most teams adopt a few quality‑of‑life features and move on. If you use analyzers with warnings‑as‑errors, you’ll spend a day making the compiler happy—worth it.

Is NativeAOT production‑ready?

For the right workloads, yes. CLIs, workers, and microservices with limited reflection/dynamic code are good candidates. Web apps heavy on plugins and dynamic proxies are usually better on the JIT for now.

What about library compatibility?

Mature libraries already support net10. If a key dependency lags, multi‑target net8.0 and net10.0 temporarily so you can ship on both.

A note on testing and telemetry you’ll thank yourself for later

Upgrade projects fail in the dark, not in code. Add synthetic transactions for your top three revenue‑critical paths. Verify TLS versions, mutual‑TLS endpoints, and custom certificate chains in non‑prod before you toggle canary traffic. If you rely on structured logging, validate your JSON schema; small serialization changes can break dashboards and alert queries.

What to do next

• Book a two‑sprint window specifically for the .NET 10 LTS move. Don’t wedge it into “misc” tickets.
• Decide your App Service path: self‑contained or container. Settle it upfront to avoid churn.
• Create a CI matrix for net8.0 and net10.0, and drop net8.0 once you’re confident.
• Pilot on one low‑risk service with real traffic replay. Measure before/after; don’t rely on vibes.
• Schedule monthly runtime patch windows so your LTS stay truly supported.

Related deep dives from our team

If you want tactical, step‑by‑step guidance we’ve already used in production, start here:

• Read our take on the upgrade calculus in Why .NET 10 LTS Is the Upgrade to Ship Now.
• If you deploy on App Service, bookmark Azure App Service and .NET 10 LTS: What to Fix Now for config and rollout patterns.
• For a structured, dates‑first approach, use .NET 10 LTS Upgrade Playbook: Dates, Risks, Wins.
• Want help planning or executing? See our services for modernization and upgrades.

Zooming out: why this upgrade pays back quickly

In practice, the biggest value in .NET 10 LTS isn’t an individual feature. It’s a cleaner baseline: faster cold starts, leaner JSON, stronger crypto defaults, and a platform you can patch on a predictable cadence. If your ops culture already does monthly maintenance windows, you’ll glide. If not, this is the release to start—future you will thank present you when the next security advisory drops.

A practical example: migrating a mid‑sized API

Picture a B2B API with three instances on App Service, 1,500 RPS peak, and a React SPA. The team uses Serilog, System.Text.Json converters, and Polly for retries. Here’s how we’d approach it:

Week one: branch, enable C# 14, fix analyzers, run tests, and publish a self‑contained artifact to a staging slot. Replay one hour of anonymized traffic with a 10% canary. Watch P95, memory, and 5xx. We usually see equal or better latency and slightly lower memory due to JSON/library improvements.

Week two: harden dashboards, enable structured log schema validation, and promote to 50% canary—then 100% with a warm slot swap. When the managed .NET 10 runtime hits GA in your region, you can flip back to framework‑dependent releases—or keep self‑contained if you prefer runtime pinning.

Common pitfalls (and how to avoid them)

• Waiting for every region to say GA: Don’t. Use self‑contained or containers and move.
• Forcing NativeAOT where reflection is heavy: Benchmark first. If DI/proxy magic is everywhere, wait.
• Skipping telemetry verification: Schema drift in logs breaks on‑call. Validate before canary.
• Changing deployment model mid‑upgrade: Settle it upfront. Your rollback plan depends on it.
• Under‑communicating the support window: Put the end dates on a wall. Deadlines drive adoption.

Final thought

The best time to modernize your production baseline is before you’re forced to. .NET 10 LTS buys you three stable years, healthier defaults, and a smoother path for security patches. Even if Azure App Service hasn’t flipped every region to GA yet, you can move today with self‑contained builds or containers, then switch back when the platform catches up.