.NET Conf 2024 kicked off this week, and with it comes the official release of .NET 9. After tracking this platform’s evolution since the early days of the original .NET Framework, I can say with some authority that the trajectory over the past few years has been remarkable. .NET 9 isn’t a revolution — it’s a refinement — but the cumulative effect of consistent, high-quality releases has made .NET one of the most compelling platforms for building modern software.
Let me dig into what matters and what it means for those of us building production systems.
Performance: The Gift That Keeps Giving#
Every .NET release brings performance improvements, and at some point you’d expect diminishing returns. .NET 9 says otherwise. The runtime team has delivered measurable gains across the board, with particular focus on areas that matter for cloud-native workloads.
The JIT compiler continues to get smarter. Dynamic PGO (Profile-Guided Optimization), which was introduced in earlier releases, has been further refined. The compiler now makes better decisions about inlining, loop optimization, and vectorization based on actual runtime behavior. In practice, this means applications that have been running for a while get progressively faster as the JIT identifies hot paths.
Server GC has received significant attention. For containerized workloads — which is how most of us deploy these days — the garbage collector is better at understanding memory pressure signals from the container runtime. This translates to fewer OOM kills and more predictable latency under load.
The numbers from the TechEmpower benchmarks continue to be impressive. ASP.NET Core has been trading top positions with Rust and C++ frameworks, which is extraordinary for a garbage-collected runtime. For most teams, the performance delta between .NET and systems languages is no longer a valid reason to choose the harder path.
Cloud-Native First#
The Aspire stack, introduced as a preview in .NET 8, reaches a more mature state with .NET 9. For those unfamiliar, .NET Aspire is an opinionated framework for building observable, production-ready distributed applications. It handles service discovery, health checks, telemetry, and configuration in a way that feels integrated rather than bolted on.
What I appreciate about Aspire’s approach is that it doesn’t try to hide the complexity of distributed systems — it just removes the boilerplate. You still need to understand service communication patterns, resilience strategies, and observability. But you don’t need to wire up OpenTelemetry exporters, configure health check endpoints, or write service discovery logic from scratch.
The integration with Azure Container Apps and Kubernetes has deepened. The aspire manifest tooling can generate deployment artifacts that map cleanly to container orchestration platforms. It’s not lock-in — the generated manifests are standard Kubernetes YAML or Bicep templates — but it does make the Azure path smooth enough that teams will gravitate toward it.
C# 13: Measured Progress#
C# 13 ships with .NET 9, and the language team continues their philosophy of incremental, well-considered additions rather than feature bloat. The headline features include:
params collections: The params keyword now works with any collection type, not just arrays. This is a small change that eliminates a surprising number of allocation-heavy patterns in everyday code.
New Lock type: A purpose-built System.Threading.Lock type that’s more efficient than locking on arbitrary objects. This is the kind of change that reflects maturity — fixing a decades-old pattern that everyone knew was suboptimal but nobody had a clean replacement for.
field keyword in properties: Semi-auto properties that let you access the backing field directly. This eliminates a whole category of “I need a full property just to add one line of validation” situations.
None of these are flashy. All of them reduce friction in daily development. That’s exactly what a mature language should be doing.
The Broader .NET Story#
Stepping back from the specific release, what strikes me is how effectively Microsoft has executed the .NET transformation over the past eight years. The journey from .NET Framework (Windows-only, closed-source, stagnant) to modern .NET (cross-platform, open-source, cutting-edge performance) is one of the most successful platform reinventions in software history.
The developer experience gap with other ecosystems has largely closed. Hot reload works well. The CLI tooling is excellent. The package ecosystem (NuGet) is mature. IDE support spans VS Code, Visual Studio, and JetBrains Rider. You can develop on Mac or Linux without feeling like a second-class citizen.
What still needs work is perception. In many tech circles, .NET still carries the baggage of its Windows-only, enterprise-only past. I regularly meet developers who dismissed .NET years ago and haven’t looked back. If that’s you, it’s worth another look. The platform in 2024 bears little resemblance to the one you left.
My Take#
I’ve been working across multiple language ecosystems throughout my career, and I use whatever tool fits the job. But I have to give credit where it’s due: the .NET team has been executing at an exceptionally high level. The annual release cadence, the commitment to performance, and the willingness to make breaking changes when necessary (the Framework-to-Core transition) have all paid off.
.NET 9 specifically is a strong release for cloud-native development. If you’re building microservices, APIs, or background processing systems, the combination of performance, observability (through Aspire), and deployment tooling is hard to beat. The Aspire framework in particular deserves more attention from the broader developer community.
The one area where I’d push Microsoft is the AI story. Every platform is racing to integrate AI capabilities, and while .NET has Semantic Kernel and various Azure AI integrations, the developer experience for building AI-powered features still feels more natural in Python. With .NET 9 laying a solid foundation, I’m hoping .NET 10 makes AI development a first-class experience.
For now, if you’re already in the .NET ecosystem, upgrade and enjoy the improvements. If you’re not, .NET 9 is as good a time as any to take a fresh look.
This is part of my Developer Landscape series, tracking the trends and shifts that shape how we build software.