.NET 10 Release: What's New (LTS) and What to Upgrade First

.NET 10 is the next Long-Term Support (LTS) release in the .NET family. LTS matters because it’s the version many teams standardize on for the next 2-3 years: you get a stable baseline, predictable support windows, and a natural time to pay down technical debt (tooling, CI images, container base images, dependency bumps).

This post is a guided tour through the high-level changes in .NET 10 and an opinionated upgrade checklist you can apply to real production codebases. If you want the canonical details per area, Microsoft provides dedicated “What’s new” pages for each component, which I link throughout.

Quick Takeaways

• Runtime: more throughput from JIT optimizations and codegen improvements; continued investment in NativeAOT and new CPU instruction support.
• Libraries: new APIs across core areas (crypto, JSON, networking, diagnostics) with a noticeable emphasis on efficiency and safety switches.
• SDK & CLI: improved dotnet test, more consistent CLI surface, better shell integration, and more first-party support for containers and tools.
• App stacks: ASP.NET Core, EF Core, MAUI, WPF/WinForms, and Aspire all ship aligned releases.
• Languages: C# 14 brings several quality-of-life improvements and new extensibility primitives.

Runtime: Performance and Optimization Work Continues

The .NET 10 runtime keeps pushing on the same levers that typically matter most in production services: fewer allocations, better inlining decisions, fewer virtual dispatches, and tighter loops.

Highlights called out in the overview:

• JIT optimization improvements, including better inlining, devirtualization, and more opportunities for stack allocation.
• New ISA support like AVX10.2.
• NativeAOT enhancements and improved code generation in areas like struct argument passing.
• More aggressive/accurate loop optimizations (for example, improved loop transformations).

Why architects should care:

• These improvements often translate into measurable reductions in CPU cost for hot paths without any code changes.
• They also reduce the gap between “idiomatic” C# and “hand-tuned” implementations by letting the JIT and libraries do more work.

Cryptography: Preparing for a Post-Quantum World

.NET 10 expands post-quantum cryptography support and also adds smaller enhancements like new primitives and algorithm support.

The overview references:

• Expanded post-quantum cryptography support (including Windows CNG integration and improvements around ML-DSA).
• Additional cryptography features such as AES KeyWrap with Padding support.

SDK & Tooling: Better Testing, Containers, and CLI Ergonomics

The .NET SDK is where most teams feel the upgrade immediately: the CLI, build output, test runner behavior, and developer experience.

Highlights from the overview:

• dotnet test gains support for Microsoft.Testing.Platform.
• CLI surface becomes more consistent (for example, standardized command order).
• CLI can generate native tab completion scripts for popular shells.
• Better first-party container workflows, including native container image creation for console apps and the ability to set the container image format explicitly.
• Improved .NET tool compatibility (including an any RuntimeIdentifier scenario), plus one-shot execution options like dotnet tool exec and related helpers.
• CLI introspection via --cli-schema.
• Continued evolution of “file-based apps” with publish support and native AOT options.

Practical guidance for teams:

• If your CI uses pinned SDKs, update the pin (global.json) and validate build reproducibility.
• If your build system wraps dotnet commands (scripts, Makefiles, Justfiles), test the updated CLI behavior and output parsing.
• If you ship containers, re-check image format settings and base images.

ASP.NET Core 10: The Web Stack Keeps Evolving

ASP.NET Core 10.0 ships alongside .NET 10 and includes updates across:

• Blazor (including performance and loading improvements)
• OpenAPI enhancements
• Minimal APIs improvements
• Identity enhancements such as passkey support

C# 14: Language Features That Remove Friction

C# 14 focuses on productivity and expressiveness while continuing the trend of making libraries easier to author and consume.

Highlights in the overview include:

• Field-backed properties (using the field contextual keyword) to evolve from auto-properties to custom accessors with less refactoring.
• nameof support for unbound generic types like List<>.
• First-class support for certain Span implicit conversions.
• Lambda parameter modifiers (ref, in, out) without specifying parameter types.
• New partial capabilities (partial instance constructors, partial events).
• extension blocks for extension methods and extension properties.
• Null-conditional assignment (?.).
• User-defined compound assignment operators and ++/-- operators.

Official docs: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14

EF Core 10: Data Access Improvements

EF Core 10.0 (EF10) is an LTS release. Two practical implications from the release notes:

• EF10 requires .NET 10 (SDK to build and runtime to run). It won’t run on earlier .NET versions or .NET Framework.
• The release notes are intentionally “major changes”; the full issue list is linked from Microsoft Learn.

Below are the concrete changes called out in the official EF Core 10 release notes.

SQL Server / Azure SQL

• Vector search support for the new SQL vector type and VECTOR_DISTANCE() (Azure SQL Database and SQL Server 2025). This is intended for embeddings and similarity search.
• JSON type support for the new SQL Server 2025 / Azure SQL json data type (more efficient and safer than storing JSON in nvarchar).
  • EF defaults to the new json type when using UseAzureSql() or SQL Server compatibility level 170+.
  • Existing nvarchar-based JSON columns can be migrated to json automatically on the first migration; you can opt out by setting column type explicitly or lowering compatibility.
• Custom default constraint names:
  • You can name default constraints explicitly.
  • You can enable automatic naming for all default constraints (note: next migration can rename many constraints).

Complex Types (Value Semantics)

EF10 continues the push toward complex types as the recommended modeling option for document-style mapping and table splitting.

• Optional complex types are supported (with the caveat that at least one required property must exist on the complex type).
• Mapping complex types to JSON is supported (single JSON column per complex type).
• Struct support for complex types (classes and structs can be used; collections of structs are not currently supported).
• Guidance: if you previously used owned entity types for JSON/table splitting, the release notes recommend switching to complex types for fewer surprises (value semantics vs identity semantics).

LINQ and Query Translation

• Parameterized primitive collections: EF10 introduces a new default translation mode which expands values into multiple scalar parameters (and pads parameter lists to reduce SQL variants), improving plan caching while also providing cardinality hints.
  • EF still allows controlling the strategy globally and per query (e.g., constant inlining vs JSON array parameter vs multiple scalar parameters).
• Support for .NET 10 LeftJoin and RightJoin operators, translated to LEFT JOIN / RIGHT JOIN in SQL.
• More consistent ordering for split queries, fixing ordering mismatches between the primary query and the included subquery.
• Additional query translations, fixes, and optimizations are listed in the release notes (including DateOnly translations, DefaultIfEmpty fixes, and various planner/parameter improvements).

Bulk Updates and Filters

• ExecuteUpdate support for relational JSON columns (when JSON mapping is done via complex types), enabling efficient bulk updates against JSON properties.
• Named query filters: multiple global query filters per entity type, and the ability to disable only selected filters per query.

Example (named query filters):

1modelBuilder.Entity<Blog>()  
2 .HasQueryFilter("SoftDeletionFilter", b => !b.IsDeleted)  
3 .HasQueryFilter("TenantFilter", b => b.TenantId == tenantId);  
4  
5List<Blog> allBlogs = await context.Blogs  
6 .IgnoreQueryFilters(["SoftDeletionFilter"])  
7 .ToListAsync();  

• ExecuteUpdateAsync accepts a regular (non-expression) lambda, making it much easier to build setters dynamically.

Example:

1await context.Blogs.ExecuteUpdateAsync(s =>  
2{  
3 s.SetProperty(b => b.Views, 8);  
4 if (nameChanged)  
5 {  
6  s.SetProperty(b => b.Name, "foo");  
7 }  
8});  

Aspire: Cloud-Native DX

Aspire ships out-of-band from .NET (major versions align, minor versions ship more frequently). For a .NET 10 upgrade, the most relevant sources are the versioned “What’s new” pages for Aspire 9.x and (if you’re jumping major versions) Aspire 13.

What’s New in Aspire 9.5 (selected highlights)

• CLI & tooling

  • Preview aspire update: scans your AppHost + packages, validates compatibility, and upgrades safely (with confirmation). It is channel-aware (stable/daily/custom).
  • Channel-aware aspire add package selection.
  • Preview file-based AppHost support (apphost.cs) behind feature flags (requires .NET SDK 10.0.100 RC1+).
  • Better SSH Remote port forwarding behavior in VS Code.
  • aspire exec improvements (for example, --workdir, clearer help, and early argument validation).

• Dashboard

  • GenAI visualizer for LLM-centric telemetry in traces (based on OpenTelemetry GenAI semantic conventions).
  • Multi-resource console logs (“All” stream) to see a single chronological log timeline.
  • Custom resource icons via WithIconName() (plus icon variants).
  • Reverse-proxy support using ASPIRE_DASHBOARD_FORWARDEDHEADERS_ENABLED=true.

• Integrations and hosting

  • New AddOpenAI hosting integration.
  • Typed model catalogs for GitHub Models and Azure AI Foundry integrations.
  • Dev Tunnels hosting integration (secure public tunnels for development).
  • YARP integration gains static files support.
  • Azure Container App Jobs support.
  • First iteration of unified Azure provisioning + deployment via aspire deploy.

• App model improvements

  • Resource lifecycle events (for example, OnResourceStopped).
  • HTTP probes for startup/readiness/liveness.
  • Enhanced waiting semantics (WaitFor vs WaitForStart), including improved external-service health honoring.
  • Breaking change: endpoint resolution in WithEnvironment callbacks now resolves container hostnames correctly (instead of always “localhost”).

Aspire 13 (major version) and .NET 10 alignment (brief)

If you’re planning a larger modernization at the same time as a .NET 10 upgrade, Aspire 13 is a major step:

• Requires the .NET 10 SDK or later.
• Simplifies AppHost project structure: the AppHost SDK is declared directly on the <Project> element (and no longer needs an explicit Aspire.Hosting.AppHost reference).
• Expands beyond .NET-only orchestration with first-class JavaScript and Python support, plus broader CLI/pipeline capabilities.

Release notes:

• https://aspire.dev/whats-new/aspire-13/

Where to Start Reading

• Overview: https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/overview
• Runtime: https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/runtime
• Libraries: https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/libraries
• SDK: https://learn.microsoft.com/en-us/dotnet/core/whats-new/dotnet-10/sdk
• ASP.NET Core: https://learn.microsoft.com/en-us/aspnet/core/release-notes/aspnetcore-10.0
• C# 14: https://learn.microsoft.com/en-us/dotnet/csharp/whats-new/csharp-14