News

What's New for C# 14 and F# 10 in .NET 10

• By David Ramel
• 11/17/2025

C# 14 and F# 10 are shipping with .NET 10, delivering coordinated updates that focus on productivity, clarity and performance across Microsoft's primary .NET languages. Both releases introduce refinements that streamline common coding patterns while also enabling improvements throughout the .NET toolchain.

C# 14 Highlights
The C# 14 release adds multiple language features designed to reduce boilerplate and make common scenarios more efficient. As Microsoft explains, "C# 14 ships with .NET 10. The highlight is new extension members, but there's a lot more features that make your life as a developer more productive."

Extension members -- which enable extension properties, extension operators, and static extension members -- are the most visible change. According to a Nov. 17 DevBlogs post, "Extension members are the headline feature of C# 14. The new syntax is fully compatible with existing extension methods." The update consolidates extension properties, extension operators and static extension members into a unified model that reduces workarounds developers used in previous versions. These members are defined using an extension block, allowing features such as extension properties and user-defined operators to appear alongside familiar patterns.

The release also includes improvements to auto property customization through the new contextual keyword for compiler-generated backing storage. Microsoft explains the intent: "The contextual field keyword creates a middle step on that evolution path: keep the auto-property terseness, inject minimal logic only where needed, and let the compiler synthesize and name the backing storage." This allows developers to modify only the accessor that requires logic while retaining the simplicity of auto properties.

Other updates include support for nameof on unbound generic types such as nameof(List<>), simplified lambda parameter modifiers (for example, out), and the ability to use null-conditional operators on the left side of assignments through constructs like customer?.Order = .... C# 14 also extends partial types to support partial events and partial constructors, improving compatibility with source generators.

Performance-related additions include implicit span conversions, allowing array slices such as buffer[..8] to convert automatically to Span<T> or ReadOnlySpan<T> without explicit calls to AsSpan. The release also enables user-defined compound assignment operators such as += on custom types, providing clearer syntax and improved opportunities for optimization in numerical and vector scenarios.

More information is provided in an accompanying video with Dustin Campbell.

F# 10 Highlights
The F# 10 release focuses on refinement and consistency. Microsoft describes the update as "a refinement release focused on clarity, consistency, and performance, bringing small but meaningful improvements that make your everyday code more legible and robust."

One of the most notable changes is scoped warning suppression. Developers can now pair #nowarn and #warnon directives to control warnings within specific code spans, improving precision compared to previous versions. This allows warnings to be enabled or disabled for individual sections without affecting entire files.

Auto property accessor access modifiers are also supported, enabling patterns such as publicly readable but privately writable members through syntax like member val Balance = 0m with public get, private set. Optional parameters can now use the struct-based ValueOption<'T> representation by applying the [<Struct>] attribute, reducing allocations in performance-sensitive code.

F# 10 also includes enhancements to computation expressions. Typed bindings in let!, use! and and! expressions no longer require parentheses, and the discard pattern (_) is now allowed in use! bindings. Tail-call support is available when builders implement optional *Final methods such as ReturnFromFinal or YieldFromFinal, enabling optimized control flows.

The release enforces attribute target validation, surfacing issues where attributes were previously accepted but ignored. As Microsoft notes, "This is a breaking change that may reveal previously silent issues in your codebase." The FSharp.Core library adds support for the and! keyword in task expressions, enabling idiomatic concurrent awaits without requiring Task.WhenAll.

Tooling and infrastructure improvements include a new type subsumption cache for faster type checking and IntelliSense responsiveness, improved trimming behavior without manual substitution files, preview parallel compilation features and extended support for typecheck-only mode in scripts using --typecheck-only.

Conclusion
The .NET 10 release wave brings coordinated updates across both C# and F#, with C# 14 emphasizing new features that streamline common development patterns and F# 10 focusing on consistency and compiler performance. Together, these releases continue the broader .NET trend toward incremental, developer-focused refinements across its language lineup.