Every few months we get a new “.NET is fading” essay. The pattern is usually the same: grab a few signals from the loudest parts of the internet, treat them as the whole industry, then declare a trend line. The real question isn’t “is .NET cool?” It’s “where is it used, where is it chosen, and what does ‘relevance’ even mean?”
This article is a polemic, a response to a piece published on Stackademic titled “.NET Is Quietly Losing Relevance — And Most Developers Don’t See It Yet”. I want to be clear upfront: this isn’t about questioning anyone’s opinion or competence. The author raises points worth discussing, and some of them land. But I believe the conclusion, that .NET is “losing relevance,” conflates two very different things. And that conflation matters, because it shapes how developers make career decisions and how teams choose stacks.
So let me offer a different frame. One built on measurable signals rather than vibes.
This isn’t a dunk
Before we go further, let me concede the ground that’s actually worth conceding.
Mindshare shifts are real. If you hang out on Twitter (or X, or whatever we’re calling it this week), browse Hacker News, or scroll through GitHub Trending, you’ll see a lot of Rust, Go, Python, and TypeScript. You won’t see as much C#. That’s not an illusion. The cultural center of gravity in developer communities has moved, and .NET isn’t where the gravity is strongest.
Narrative has gravity. When new developers are choosing their first “real” language, they’re influenced by what they see. If the most visible, most exciting projects are written in other languages, that shapes perception. Perception shapes adoption. Adoption shapes ecosystem growth. This is a feedback loop, and it’s worth taking seriously.
What I don’t accept is the leap from “less visible” to “losing relevance.” Those are different claims, and they require different evidence.
Define your terms: Relevance vs mindshare
Here’s where most “.NET is dying” takes fall apart. They treat mindshare as a proxy for relevance, when these are actually orthogonal axes.
Relevance is operational. It answers questions like:
- How much production software runs on this stack?
- How many companies are hiring for it?
- Is the ecosystem healthy, meaning are libraries maintained, are tools improving, is the core runtime actively developed?
- Does it solve real problems for real teams at reasonable cost?
Mindshare is perceptual. It answers questions like:
- What do beginners learn first?
- What trends on social media?
- What do people tweet about, blog about, build side projects in?
- What feels exciting?
These can correlate, but they don’t have to. COBOL has near-zero mindshare and enormous relevance in banking. Rust has massive mindshare and (currently) modest production footprint outside specific domains. Neither of those facts makes one language “better” than the other. They’re just operating in different quadrants.
Here’s a simple mental model:
The claim that .NET is “losing relevance” places it in the bottom-left quadrant. The data, as we’ll see, places it firmly in the bottom-right. Less loud, still massively relevant.
Why the original article’s signals skew the outcome
The original piece makes several observations that are true but misleading when used to draw conclusions about relevance.
Startup “preference” depends on which startups you look at
The article notes that startups increasingly choose Node, Python, or Go over .NET. This is partially true, but it’s also a sampling bias. If you’re looking at YC-backed startups building developer tools, infrastructure, or AI products, yeah, you won’t see much .NET. Those domains have their own gravitational pull toward specific stacks.
But if you look at startups in fintech, healthtech, enterprise SaaS, or anything selling to large organizations, .NET is everywhere. These startups don’t get as much tech press coverage. They’re not launching on Product Hunt. They’re grinding through SOC 2 compliance and enterprise sales cycles. And they’re often choosing .NET precisely because their customers run Microsoft shops.
GitHub Trending is not a market share dashboard
GitHub Trending measures what’s new and exciting, not what’s widely used. It overrepresents:
- Developer tools and CLI utilities (heavily Go and Rust)
- Frontend frameworks (JavaScript/TypeScript)
- AI/ML projects (Python)
- OSS-first infrastructure (Go, Rust)
It underrepresents:
- Enterprise backends (Java, C#)
- Internal business systems (C#, Java, PHP)
- Proprietary software (everything)
This isn’t a flaw in GitHub Trending. It’s just what it measures. Using it to assess .NET’s relevance is like using Instagram to assess the popularity of accounting software.
Enthusiasm Is Not a Proxy for Economic Value
The loudest communities are not necessarily the largest. Rust developers are incredibly enthusiastic and vocal. They also represent a small fraction of production software. Python’s data science community generates enormous content. That doesn’t mean Python is the most-used language in enterprise backends (it isn’t).
.NET developers tend to be less loud. They’re often working in enterprises where blogging isn’t part of the culture. They’re building line-of-business apps that will never be open-sourced. They’re not chasing Twitter followers. This makes them invisible in certain metrics while being extremely present in others.
A better evidence set
Alright, enough critique. Let’s look at what the data actually says.
TIOBE index: C# is growing, not shrinking
In January 2026, TIOBE named C# the Programming Language of the Year for 2025 [src][src]. C# saw the largest year-over-year increase in the TIOBE top 10, rising 2.94 percentage points to a 7.39% rating [src][src].
Let me repeat that: the index that tracks programming language popularity over time just gave .NET’s primary language its highest honor. This isn’t a participation trophy. It’s measured growth.
Now, TIOBE isn’t perfect. It measures search engine queries, which has its own biases. But it’s a longitudinal dataset, and the trend line is up, not down.
Stack Overflow Developer Survey: Still mainstream
The 2025 Stack Overflow Developer Survey continues to show C# as a mainstream language [src]. It’s not the top language (Python and JavaScript hold those spots), but it’s consistently in the upper tier. More importantly, the survey shows strong usage in professional contexts, not just hobbyist projects.
The “admired vs dreaded” metrics have improved significantly for .NET over the past several years as the platform modernized. Modern .NET (post-.NET Core) is genuinely pleasant to work with, and developers have noticed.
NuGet ecosystem: Healthy and growing
NuGet, the .NET package manager, processes billions of downloads per year. The package count continues to grow, and major libraries are actively maintained. This matters because ecosystem health is a leading indicator. If .NET were truly dying, you’d see library abandonment, reduced package publishing, and maintainer burnout. Instead, you see continued investment.
The .NET Foundation and Microsoft’s first-party libraries (ASP.NET Core, EF Core, MAUI) receive regular updates on a predictable schedule. .NET 9 shipped on time with meaningful improvements. .NET 10 is on track. This is not the behavior of a dying ecosystem.
Blazor: The growth story nobody talks about
Here’s a number that surprised me: Blazor deployments grew from approximately 12,500 live sites in November 2023 to nearly 40,000 in early 2025, and some sources report the number surging past 149,000 by mid-2025 [src][src].
That’s not hype. That’s production adoption. Blazor isn’t going to replace React (and it’s not trying to), but it’s carving out a real niche, particularly in enterprise scenarios where teams want to share code between frontend and backend, or where C# expertise is deeper than JavaScript expertise.
.NET 10 shipped meaningful improvements to Blazor and ASP.NET Core, focusing on performance, state management, and asset handling [src]. Microsoft is clearly investing here.
Enterprise cloud: Azure’s .NET advantage
Microsoft was named a Leader in the 2025 Gartner Magic Quadrant for Cloud-Native Application Platforms [src][src]. This matters for .NET because Azure and .NET are deeply integrated. Azure App Service, Azure Functions, Azure Container Apps, all of these have first-class .NET support with optimized cold start times, native AOT options, and tight tooling integration.
If your organization is already in the Microsoft ecosystem (and many large enterprises are), .NET is often the path of least resistance. That’s not a weakness; it’s a strategic advantage.
Where .NET actually dominates
Let’s be specific about the domains where .NET isn’t just “relevant” but is often the default choice.
Internal business systems and B2B SaaS
The unsexy truth is that most software isn’t consumer-facing apps or developer tools. It’s internal business systems: HR platforms, inventory management, CRM customizations, reporting dashboards, workflow engines. .NET dominates this space, particularly in organizations with Windows infrastructure.
These systems don’t show up on GitHub Trending. They don’t get Product Hunt launches. They just quietly run businesses, year after year.
Regulated industries: Finance, healthcare, government
When you need audit trails, compliance certifications, and long-term support guarantees, .NET is attractive. Microsoft’s enterprise support model, the predictability of the release cycle, and the maturity of the tooling all matter in contexts where “move fast and break things” is a liability, not a virtue.
Banks run .NET. Insurance companies run .NET. Healthcare systems run .NET. Government agencies run .NET. These are not small niches.
Game development via unity
Unity powers somewhere between 50–70% of mobile games and a significant chunk of indie and mid-tier PC/console games. Unity scripting is C#. This means millions of developers write C# regularly who might not identify as “.NET developers” at all.
When people say “C# is only for enterprise,” they’re ignoring one of the largest game engines in the world.
Azure-centric organizations
If your company has committed to Azure as its cloud platform (and many large enterprises have), .NET gets a natural advantage. The integration is tighter. The tooling is better. The performance optimizations are deeper. You can run Node or Python on Azure, but you’re swimming against the current somewhat.
Where the critique is fair
Now let me give credit where it’s due. The original article isn’t wrong about everything.
The “cool factor” and beginner on-ramps
If you’re a new developer in 2026, your first exposure to programming is probably:
- Python (data science, AI hype, beginner-friendly syntax)
- JavaScript (web development, immediate visual feedback)
- Maybe Rust or Go if you’re hanging out in certain communities
C# and .NET are rarely the first thing people learn anymore. The on-ramp is perceived as heavier. Visual Studio is intimidating. The historical baggage of .NET Framework vs .NET Core vs .NET 5+ is confusing. The getting-started experience, while improved, still feels more “enterprisey” than alternatives.
This matters. First languages shape career trajectories. If fewer people start with .NET, the long-term pipeline narrows.
Fragmentation perception
The .NET ecosystem went through a messy transition. .NET Framework, .NET Core, .NET Standard, Xamarin, MAUI, the naming and versioning history is genuinely confusing for newcomers. Even though modern .NET (version 6+) has largely unified things, the historical memes persist.
When someone says “.NET is confusing,” they’re often reacting to something that was true five years ago but isn’t anymore. But perception lags reality, and Microsoft hasn’t done enough to update the narrative.
OSS culture perception
Python and JavaScript have vibrant, visible open-source cultures. Conferences, Twitter personalities, prolific bloggers, and a general sense of community energy. The .NET community has this too, but it’s smaller and quieter.
Some of this is structural. Enterprise developers often can’t open-source their work. Some of it is cultural. The .NET community skews older and more professional, less interested in social media clout. But the result is that .NET feels less “alive” even when the ecosystem is healthy.
What modern .NET actually looks like
Part of the narrative problem is that people’s mental model of .NET is frozen in 2015. Let me show you what a modern .NET service actually looks like.
Minimal APIs with observability
Here’s a production-ready API in about 30 lines:
using OpenTelemetry.Metrics;
using OpenTelemetry.Trace;
var builder = WebApplication.CreateBuilder(args);
// Add OpenTelemetry
builder.Services.AddOpenTelemetry()
.WithTracing(tracing => tracing
.AddAspNetCoreInstrumentation()
.AddHttpClientInstrumentation()
.AddOtlpExporter())
.WithMetrics(metrics => metrics
.AddAspNetCoreInstrumentation()
.AddRuntimeInstrumentation()
.AddOtlpExporter());
// Add health checks
builder.Services.AddHealthChecks()
.AddCheck("self", () => HealthCheckResult.Healthy());
var app = builder.Build();
app.MapHealthChecks("/health");
app.MapGet("/", () => "Hello, Production!");
app.Run();That’s a service with distributed tracing, metrics export, and health checks, ready to run in Kubernetes. The ceremony-to-functionality ratio is competitive with any modern framework.
Blazor interactive server component
And here’s a taste of Blazor for those curious about the web story:
@page "/counter"
@rendermode InteractiveServer
Counter
Current count: @currentCount
class="btn btn-primary" @onclick="IncrementCount">Click me
@code {
private int currentCount = 0;
private void IncrementCount()
{
currentCount++;
}
}No JavaScript. Full type safety. Hot reload. Server-side rendering with selective interactivity. It’s not React, and it’s not trying to be. But for teams that want to stay in C#, it’s a legitimate option now.
What “winning” looks like from here
If we’re honest about the situation, .NET has a relevance advantage and a narrative disadvantage. Here’s what fixing that looks like:
For Microsoft
- Reduce first-run friction. The “hello world to production” path needs to be faster and simpler.
dotnet newtemplates should include observability, health checks, and Docker configuration by default. - Improve the story. Stop talking about migration paths from .NET Framework. New developers don’t care. Talk about what modern .NET enables: performance, cloud-native design, and cross-platform deployment.
- Invest in community signal boosting. Highlight .NET projects that aren’t enterprise CRUDs. Game development, embedded systems, high-performance computing. The interesting stuff exists; it’s just not visible.
For teams choosing stacks
- Choose based on constraints, not vibes. What does your team know? What does your infrastructure support? Who will you hire? These questions matter more than what’s trending on Hacker News.
- Treat developer experience and hiring pipeline as first-class constraints. If you can’t hire .NET developers in your market, that’s a real problem. If you can (and in many markets, you can), it might be an advantage.
- Benchmark your actual workload. Modern .NET is genuinely fast. If performance matters, test it. Don’t assume based on reputation.
For individual developers
- Pick a lane and go deep. .NET is still a high-leverage lane in many markets: enterprise, fintech, game development, Windows ecosystem. If you’re in one of those markets, doubling down makes sense.
- Learn the modern patterns. If your mental model of .NET is from 2015, update it. Minimal APIs, source generators, native AOT, Blazor, MAUI, the platform has moved significantly.
- Don’t let Twitter determine your career. The loudest voices aren’t representative. Look at job boards, not trending topics.
The sane conclusion
.NET isn’t “quietly dying.” It’s not even “losing relevance” in any measurable sense. What it’s losing is narrative. It’s less visible, less hyped, less present in the spaces where developer culture happens loudest.
That’s a real problem, but it’s a different problem than the one the original article diagnoses. And it’s a solvable problem.
The actual evidence tells a story of a mature, performant, well-maintained platform with strong enterprise adoption, active ecosystem growth, and continued investment from one of the largest tech companies in the world. C# was literally named the programming language of the year. Blazor deployments are growing rapidly. The cloud-native story is solid.
If we want to have a serious conversation about .NET’s trajectory, let’s bring time-series data, not rhetorical questions. Let’s define our terms, not conflate mindshare with relevance. Let’s acknowledge that different stacks serve different contexts, not declare winners based on which ecosystem is loudest on social media.
The .NET party might not be the loudest one on the block. But there’s a lot of production software getting built there, a lot of developers getting paid there, and a lot of businesses running there.
That sounds pretty relevant to me.