Reading · Sebastian Gingter

November 2025 was the month where the preview phase stopped being theory and turned into actual decisions.

.NET 10 shipped. C# 14 shipped. ASP.NET Core 10 and EF Core 10 shipped. Aspire took a noticeably bigger step. Visual Studio 2026 and Rider 2025.3 were ready right away. And .NET Conf 2025 turned the whole thing into a very public statement about where the platform wants to go next.

This was not a month for casual catch-up.

What made this month interesting was not just the amount of news. It was the fact that almost every part of the stack suddenly became immediately relevant again: runtime, language, web stack, data access, cloud-native tooling, IDEs, and the increasingly unavoidable AI tooling story around .NET.

So let’s walk through the highlights.

.NET 10 is the big one

Let’s start with the obvious headliner: .NET 10 is here, and this is the release most production teams should pay attention to.

Why? Because this is an LTS release, supported through November 2028. That alone makes it relevant. Not every team can or should jump on every yearly release immediately, but LTS releases are different. They are the ones you usually plan around.

And this one does not arrive empty-handed.

Microsoft shipped .NET 10 with more than 23,000 pull requests merged, which gives you a rough idea of the sheer amount of movement behind the scenes. On the technical side, the release brings JIT improvements, AVX10.2 support, better code generation, NativeAOT improvements, and expanded post-quantum cryptography support. That is a pretty healthy mix of day-to-day developer value and long-term platform investment.

What I like here is that the release does not try to be clever for the sake of it. It focuses on the things that matter: performance, deployment, security, and developer productivity. Smaller, faster NativeAOT binaries are not academic nice-to-haves anymore. They matter when you care about startup time, memory use, container density, or just getting leaner services into production.

This is one of those releases where “you should probably take a serious look at it” is not marketing fluff. It is simply true.

C# 14 removes friction in the right places

C# 14 ships alongside .NET 10, and the best thing about this release is very simple: it removes ceremony in places where ceremony had become annoying.

Yes, extension members are the flashy headline. They are important too. Extension members go beyond classic extension methods and open the door to extension properties, operators, and static members. That is a real language evolution, not just syntactic sugar with a shiny ribbon around it.

But the feature many teams will probably appreciate most in daily work is the field keyword for semi-auto properties. This closes a weird gap we have lived with for a long time: you start with an auto-property, then suddenly you need one tiny bit of logic, and boom, now you have a manually managed backing field. The new approach is simply cleaner.

The same goes for null-conditional assignment, implicit Span<T> conversions, nameof support for unbound generics, partial constructors and events, and user-defined compound assignment operators. None of these features alone would justify a parade. Together, though, they make the language feel more polished.

That is the kind of release I want from C#: not gimmicks, not “look what we can do,” but steady, practical improvement.

ASP.NET Core 10 keeps sanding off sharp edges

The best ASP.NET Core releases are often the ones that make you fight the framework a little less. ASP.NET Core 10 feels very much like one of those.

Some of the highlights are easy to like immediately: OpenAPI 3.1 is now the default, passkey/WebAuthn support is landing in Identity, and Blazor gets improvements such as preloading of framework assets and other WebAssembly-related refinements. There are also enhancements around validation, NativeAOT, and Kestrel’s memory behavior.

None of this is flashy in the “conference keynote demo” sense. But it is the kind of work that improves real applications.

OpenAPI 3.1 by default is a good example. It is not the sort of thing that makes people cheer in a keynote, but it makes interoperability and API tooling more aligned with where the ecosystem is today. The same is true for passkeys: authentication has needed a better user experience for years, and every framework feature that helps move us away from brittle password habits is welcome.

Blazor, meanwhile, keeps getting more serious. The WebAssembly story is not standing still, and the steady work on loading behavior, assets, streaming, and diagnostics shows that Microsoft continues to invest rather than just keeping it on life support.

EF Core 10 gets more interesting for modern workloads

EF Core 10 is one of the most interesting parts of this release wave because it reflects where application development actually is now instead of where it was five years ago.

Yes, there are classic ORM improvements, including named query filters and other LINQ enhancements. Those are useful, overdue, and will make a lot of code cleaner.

But the bigger story is elsewhere.

EF Core 10 adds first-class support for vector similarity search on Azure SQL and SQL Server 2025, native JSON column support there as well, plus full-text search and hybrid search support for Azure Cosmos DB. That is not accidental. It is a clear sign that database-backed applications increasingly need to mix traditional relational data with search, embeddings, and structured document-style payloads.

In other words: the world got messier, and EF Core is adapting.

That is exactly the right move. A modern data access layer cannot pretend that every interesting application problem is still just rows, columns, and a few joins. Search matters. Vectors matter. JSON matters. If your data stack ignores that, it becomes less relevant very quickly.

Aspire 13 has clearly grown up

If you still think of Aspire as “that .NET demo thing for distributed apps,” November 2025 was a good month to revisit that assumption.

The version jump from 9.x straight to 13 already told you this was not a routine point release. More importantly, the release makes the direction unmistakable: first-class support for Python and JavaScript, the new aspire do pipeline concept, a preview MCP server in the Dashboard, and the new aspire.dev home on the web.

That is not a tidy little version bump. That is a product becoming much more explicit about what it wants to be.

And what it wants to be, clearly, is a serious orchestration and developer experience layer for polyglot applications.

That is the right call. The average real-world system is not pure .NET. It just isn’t. There is a Node frontend somewhere, maybe a Python service, maybe multiple data stores, maybe containers, maybe cloud resources. Tooling that pretends otherwise is solving a fantasy problem.

Aspire does not solve every problem yet. Of course not. But the direction has become much clearer now, and much more interesting.

The tooling story moved just as fast

November was not just about frameworks and runtimes. The IDE landscape moved too.

Visual Studio 2026 went GA, and yes, “first intelligent developer IDE” is exactly the kind of slogan that can trigger a small internal eye roll. But underneath the marketing line there is real work. The IDE reportedly cuts UI hangs by more than 50%, gets a redesigned UI, improves Copilot integration, stays compatible with Visual Studio 2022 projects and extensions, and finally decouples the IDE from the build tools so updates no longer have to drag the toolchain with them.

The performance work matters most here. Every IDE team talks about AI now. Fine. But if your editor lags, hangs, or makes large solutions feel painful, all the AI sparkle in the world will not save the experience. So fewer UI hangs? Good. More of that, please.

JetBrains answered quickly with Rider 2025.3, bringing day-one .NET 10 and C# 14 support, startup improvements, the Islands theme as the default look, and an expanded Monitoring tool that now detects ASP.NET and database issues more directly.

That competition is healthy. Very healthy. Developers win when the tooling vendors have to keep up with platform releases immediately instead of whenever it fits the roadmap.

.NET Conf 2025 showed where the platform is heading

Then there was .NET Conf 2025, which did more than celebrate the release train. It also made the overall direction of the ecosystem pretty obvious.

On one side, the conference reinforced the traditional strengths: performance, cloud-native development, Blazor, diagnostics, and the broader .NET 10 platform story.

On the other side, it leaned hard into AI-related developer tooling and agent scenarios.

That includes the public preview of the Microsoft Agent Framework for .NET, the public preview of the MCP C# SDK, GitHub Copilot app modernization for .NET, and Copilot-powered testing support for .NET. Whether you are excited about that direction or skeptical of parts of it, one thing is pretty clear now: AI is no longer being treated as some external add-on floating around the ecosystem. It is part of the platform conversation.

That does not mean every team should suddenly go and bolt agents onto everything. It does mean the platform vendors are trying to make .NET a first-class place to build AI-enabled, tool-using, workflow-oriented applications. And unlike a year ago, that story is starting to look much more coherent.

What I would actually do next

If you are working in the .NET ecosystem, here is my practical takeaway from this month:

If you are on .NET 8, start evaluating your path to .NET 10 now.
Adopt C# 14 features where they reduce noise, not where they just make code look more fashionable.
Review ASP.NET Core 10 and EF Core 10 features against your real backlog, especially around OpenAPI, authentication, JSON, and search/vector scenarios.
Take another look at Aspire if you previously dismissed it as “not for us.”
And if you care about productivity, test both Visual Studio 2026 and Rider 2025.3 with one of your real solutions, not a toy sample.

November 2025 was not just loud. It was consequential.

Launch months always create noise. The difference this time was that most of the noise pointed to things teams can actually use, evaluate, or plan around right now.

.NET News November 2025