Microsoft has pushed out the sixth preview of .NET 11, giving developers an early look at the performance gains, language tweaks, and framework refinements coming later this year. The update is available now for testing, with the full stable release still on track for November.

A Quick Overview

Announced on July 14, .NET 11 Preview 6 continues the iterative improvements that started with the first preview in February. You can grab the build from the official .NET site and start checking how your apps behave under the new runtime and tooling.

This release touches almost every layer of the stack: the core runtime, base libraries, ASP.NET Core, .NET MAUI, and both C# and F#.

Faster Async and JIT Optimizations

Async performance keeps getting better. Preview 6 builds on the suspension work from Preview 5 and adds the ability for async continuations to skip ExecutionContext capture and restore when it’s not needed, cutting down on overhead in hot paths.

The JIT is also smarter about async. Instead of routing through a thunk, it now emits a dedicated runtime-async version of synchronous, task-returning methods. Tail calls are transformed into runtime-async calls, and the task is awaited directly, removing an extra indirection layer in the async path.

On the numeric side, Math.BigMul(long, long, out long) is now noticeably faster on x64. When both inputs are 64-bit and the caller needs the high half of the result, the JIT emits a single MUL r/m64 instruction instead of calling a helper, trimming call overhead for big-integer math.

System.Text.Json Meets C# Union Types

System.Text.Json now understands the new C# union types. The serializer detects a union via the JsonTypeInfoKind.Union contract, correctly reads and writes the active case, and works with both the reflection-based pipeline and the source generator.

New APIs like JsonUnionAttribute, JsonUnionCaseInfo, and type-classifier hooks let you control how union cases are discovered, named, and serialized, giving you more flexibility when modeling domain types.

C# Gets Extension Indexers

C# rounds out the extension members story that began in .NET 10. After extension methods and properties, Preview 6 adds extension indexers. You can now declare this[...] access inside an extension block, letting you add indexer-like behavior to types you don’t control without wrapping or inheriting.

Better Debugging in F#

F# developers get a nicer debugging experience. The compiler now emits improved sequence points for several common patterns:

• Call arguments that require stack-empty debug points
• for loops and comprehensions
• Simple literal bindings
• if and match conditions

The result is more reliable breakpoints and smoother stepping in these scenarios.

ASP.NET Core and .NET MAUI Updates

In ASP.NET Core, minimal API validation now supports asynchronous validators end-to-end, making it easier to plug in complex, I/O-based validation logic without awkward workarounds.

.NET MAUI sees several structural improvements:

• Continued evolution of the cross-platform CollectionView and Shell architecture
• Removal of the legacy Xamarin.Forms compatibility package
• Apple workloads aligned with stable Xcode 26.6

HybridWebView’s JavaScript interop has been rewritten to use a source generator instead of reflection. This eliminates trim and Native AOT warnings and ensures correct behavior in fully trimmed and Native AOT apps.

Smoother TypeScript + Razor Integration

For mixed front-end/back-end setups, projects using Microsoft.TypeScript.MSBuild in Razor Class Libraries now correctly wire TypeScript compilation outputs into ASP.NET Core Static Web Assets. That means fewer manual steps and fewer surprises when building and publishing.

What to Do Next

If you’re already on .NET 11 previews, this is a good time to run your test suites, check performance-sensitive code, and report any issues before the November GA. If you’re still on .NET 10 or earlier, Preview 6 is a solid entry point to start evaluating what’s coming.