What's new in .NET 10

.NET 10 is the successor to .NET 9 and is a Long-Term Support (LTS) release.
It’s expected to reach general availability around November 2025.
Support length: three years of support.

These are some of the under-the-hood changes in the .NET 10 runtime to make apps faster, more efficient, and reduce overhead.

Feature	What it does / why it helps
Array interface method devirtualization & array enumeration de-abstraction	The JIT has improvements so that using array interfaces (e.g., when you loop `IEnumerable` over an array) has much lower overhead. The abstraction penalty (indirection, etc.) is being reduced.
Stack allocation of small fixed-sized arrays of value types	Allows arrays of value types (without GC pointers) that are small and fixed size to be allocated on the stack rather than the heap. This reduces pressure on the garbage collector.
AVX 10.2 support (vector extensions)	Adds new CPU instruction support (Advanced Vector Extensions: AVX10.2) for x64 that can speed up numeric, AI/ML, and other heavy computational workloads when enabled.
Better inlining, loop inversion, code gen, etc.	Various optimizations: method inlining, better code generation for struct arguments, and more aggressive loop transformations (e.g. loop inversion) to improve performance.

There are quite a few new or improved APIs and library features in .NET 10.

Area	Changes / New Features
Serialization / JSON	- New JSON serialization options: strict settings, ability to disallow duplicate properties, `PipeReader` support for efficiency. - Enhanced JSON patch (in ASP.NET Core) using `System.Text.Json` rather than older `Newtonsoft` -based.
Cryptography / Security	- Expanded support for post-quantum cryptography: new algorithms, Composite ML-DSA, enhancements via Windows CNG. - AES KeyWrap with padding support. - Improved certificate handling (e.g. `FindByThumbprint` supports more secure hash algorithms).
Globalization & Text / Numerics	- New compare options for string comparison: `CompareOptions.NumericOrdering` so strings with numbers sort “naturally” (e.g. “10” after “2” etc.). - New ISOWeek overloads that directly operate with `DateOnly` . Simplifies week-based calculations without converting to `DateTime` .
Collections / Zip / Compression	- ZipArchive gets performance improvements. Some new async zipped APIs. Better memory usage for large or multiple compressed files. - GZipStream improved for concatenated streams.
Networking / Process management	- `WebSocketStream` added for simpler usage of `WebSocket` . - TLS 1.3 support for macOS clients. - Windows process group support for better signal isolation.

Improvements in the SDK, CLI, deployment, etc. include:

CLI & Command-line tooling
- Standardized CLI command ordering.
- CLI introspection via --cli-schema .
- Native tab-completion scripts generation for popular shells.
Container / Native AOT / Deployment
- Console apps can more easily create container images natively.
- New property to explicitly set the format of container images.
- Enhanced file-based apps and better native AOT (Ahead-Of-Time compilation) support.
Test / Tools
- Support for Microsoft.Testing.Platform in dotnet test .
- Platform-specific .NET tools, one-shot tool execution with dotnet tool exec .

C# 14 comes along with .NET 10 and introduces several new features:

Field-backed properties: smoother path from auto-implemented properties to custom get/set with field access.
nameof supports unbound generic types, e.g. nameof(List<>) .
Implicit conversions of Span<T> and ReadOnlySpan<T> .
Lambdas can use parameter modifiers ( ref , in , out ) without having to specify parameter types.
Partial instance constructors, partial events (in addition to partial methods/properties in earlier versions).
Extension blocks: support for static extension methods and static/instance extension properties.
Null-conditional assignment operator using ?. (i.e. something like x?.Property = value ).
User-defined compound assignment operators like += , -= , as well as user‐defined increment ( ++ ) and decrement ( -- ) operators.

New language features (some behind preview flags) with .NET 10 SDK.
FSharp.Core standard library updates applied by default (unless you explicitly pin to an earlier version).
General compiler/compiler service improvements and bug fixes.

Enforcing of the unmanaged generic constraint (helps when interoperating with lower-level APIs).
The compiler respects OverloadResolutionPriorityAttribute , which, among other things, helps prefer span-based overloads and resolves certain ambiguities faster.

Updates and improvements in the larger application frameworks built on .NET 10:

ASP.NET Core
- OpenAPI 3.1 support, including generating YAML specs.
- Automatic memory pool eviction in server implementations (Kestrel, HTTP.sys, IIS) – when the app is idle or under light load, memory blocks are released instead of held.
- Better form validation, diagnostics enhancements.
Blazor
- Enhancements like RowClass in QuickGrid, for conditional styling of rows.
- Blazor WebAssembly preloading.
- Improvements to script asset handling (serving scripts as static assets, etc.).
.NET MAUI / Mobile / Platforms
- Enhancements in file selection (multi-file), image compression, and WebView request interception.
- Support for newer Android API levels (35, 36), etc.
EF Core
- LINQ enhancements: better translations for certain queries, more flexibility.
- Named query filters allowing multiple filters per entity type with selective disabling.
Desktop UI (Windows Forms, WPF)
- Windows Forms: some clipboard-related improvements, porting UITypeEditors from .NET Framework, and general quality improvements.
- WPF: performance improvements, updates to internal data structures to reduce allocations (especially in UI automation/file dialogs/pixel format conversions). Fluent style changes.

While many features are additive or opt-in, there are some things to be aware of when upgrading:

Some features are still in preview ; behavior may change, and some APIs are marked experimental.
Deprecation or removal of legacy behaviors, especially in serialization, older cryptographic algorithms, etc. You may need to adjust code that depends on older APIs.
Performance regressions are possible in corner cases (especially for code paths that were heavily optimized under previous versions). Testing is important.
Some changes affect the behavior of JSON deserialization (strictness, duplicate property handling) that may break assumptions in existing code.
Native AOT and trimming may cause issues if code uses reflection heavily, or assumes certain behaviors that aren’t safe in trimmed or AOT contexts.

If you’re using .NET now, upgrading to .NET 10 should offer:

Better performance, especially for high-throughput, compute-intensive, or memory-sensitive applications (due to JIT improvements, stack allocations, etc.).
Better security and cryptographic readiness (post-quantum crypto, better certificate handling).
More expressive, safer, and cleaner code via new C# 14 features. Less boilerplate in many cases.
More efficient web apps ( ASP.NET Core / Blazor), especially under load, due to memory pool eviction, improved JSON handling, etc.
Improved mobile/cross-platform UI experience (through .NET MAUI enhancements).