Bring .NET to Windows and Linux, Make .NET great again!

[niltor]

In 2026, Microsoft should consider a strategic decision—integrate .NET SDK into the operating system. This will have profound implications for the entire development ecosystem.

💡 Opening: A New World Opened by Single-File Execution

.NET 10 has made significant progress in multiple areas, and the support for single-file execution opens possibilities for new use cases. A single .cs file is a complete program, providing the foundation for a transformation in development paradigms.

Practical application scenarios enabled by single-file execution:

• Zero-Deployment Web Services - Write preview.cs with just ten lines of code using ASP.NET Core to serve static file directories, no need to install http-server
• Rapid AI Agent Iteration - Use Microsoft Agent Framework to directly converse with large language models with dozens of lines of code, requiring only a single .cs file
• Goodbye to Script Files - Replace ps1/bash scripts and CI/CD scripts with .cs, eliminating the need to learn multiple scripting syntaxes, just one .cs file
• Cross-Platform Development - Run desktop applications, web apps, and console tools directly from a single file without packaging or publishing
• Remote Diagnostics - Send AI-generated diagnostic code for customers to run directly, no application installation needed, significant value for SaaS remote support
• Ultra-Fast Sharing - Share code snippets through any channel; recipients can run them without installing applications

Core Value: One .cs file = a complete, type-safe, high-performance .NET program. In many scenarios, you no longer need complex toolchains, CI/CD, or Docker—just a single .cs file.

🔍 The Barrier to Overcome

Single-file execution is excellent and powerful, but it has one prerequisite: the need to install .NET 10 SDK, the final wall that needs to be broken down.

Current Challenge: Users must install .NET SDK first to run .cs files, and this prerequisite immediately raises the barrier to entry.

Solution: Make .NET SDK part of the operating system—starting with Windows, then extending to mainstream Linux distributions.

🎯 Strategic Value One: Cognitive Shift

When Windows or mainstream Linux distributions come with .NET SDK pre-installed, the perception of new developers and users will gradually change.

With integrated .NET SDK, Windows will possess a unified, fully-featured development toolchain and a .NET runtime environment. With this advantage, it will become the most convenient operating system for getting started with programming and the preferred platform for running .NET applications.

Looking back, many Linux distributions pre-installed Python and PHP environments years ago, which greatly promoted the popularity of these languages. Developers on these systems could directly start writing and running scripts without additional installation, and they were considered developer-friendly operating systems.

Unlike the outdated and closed .NET Framework, modern .NET is now widely recognized by developers. Bringing .NET SDK directly to the operating system won't cause resentment; instead, it will be seen as a developer-friendly move. Its single-file execution capability is more powerful and offers greater possibilities.

⚡ Strategic Value Two: Unified Toolchain Standard

In the development industry, toolchains are an unavoidable topic. .NET is exemplary in this regard. When an operating system comes with a standard toolchain, both developers and users benefit greatly. It will also encourage other ecosystems to reflect on and improve themselves.

Let's look at the two hottest ecosystems:

Comparison: Tool Chain Fragmentation in Mainstream Ecosystems

Python Ecosystem:

Dependency Management: pip → venv/virtualenv → Poetry/Pipenv → requirements.txt/Pipfile
Build Tools: setuptools → wheel → flit → poetry → hatch
Test Frameworks: unittest → pytest → nose → hypothesis
Code Checking: pylint → flake8 → black → isort → mypy
Deployment Tools: gunicorn → uwsgi → docker

Python developers need to learn and maintain 7-8 different tools, with varying configurations for each project.

Node.js Ecosystem:

Package Management: npm → yarn → pnpm (incompatible lock files)
Build Tools: webpack → Rollup → Parcel → Vite → Turbopack
Test Frameworks: Jest → Mocha → Vitest → Playwright
Node.js developers face **dependency hell and frequent tool replacements**.

### .NET's Unified Advantage: One Command Solves Everything

From .NET Core 1.0 to .NET 10, **a single `dotnet` command unifies everything**:

```bash
dotnet new          # Project creation
dotnet build        # Compilation
dotnet test         # Unit testing
dotnet run          # Execution
dotnet publish      # Publishing (including AOT compilation, containerization)
dotnet tool         # Tool management
dotnet add package  # Dependency management
dotnet format       # Code formatting
dotnet diagnostics  # Performance diagnostics
dotnet ef           # Database migrations

Key Advantage: No need for version management tools; multiple versions can be installed simultaneously without interference.

Important

While other ecosystems tout the performance gains of rewriting toolchains in Rust, .NET solved all these problems with a single dotnet command from its first version. Oh, and by the way, .NET doesn't need version management tools—multiple versions can be installed simultaneously without interference

• Lower Barrier to Entry - All .NET ecosystem documentation can eliminate the "install SDK first" prerequisite
• Developer Priority - Developers and publishers prioritize environments natively supported by the system
• AI Tool Rise - AI CLI tools will prioritize .NET because users don't need to install additional runtimes
• System Tool Upgrade - Windows non-core tools can be developed in .NET, with built-in cross-platform capabilities, eliminating WebView2
  , becoming more user-friendly
• Developer Priority - Whether developers or publishers, they will prioritize environments natively supported by the system itself, without needing users to install and configure additional runtimes
• AI Tool Rise - Various CLI tools will start considering .NET as the preferred development language because users don't need to install additional runtime environments
• System Tool Upgrade - Windows non-core tools can be developed in .NET, with built-in cross-platform capabilities, eliminating WebView2

Whether for developers or users, this rImpactgnificant transformation in both developmenton

Pain Points of Current Approaches:

• Traditional Applications - Installation packages, registry pollution, uninstall remnants
• Package Managers - npm, pip, apt operate independently, fragmented ecosystems
• Container Technology - Solves dependencies but introduces additional complexity and resource overhead

New Possibilities with System-Level .NET SDK:

• NuGet as Application Distribution - dotnet tool becomes an application installer
• Code as Application - A single .cs file or code snippet can be distributed and executed
• Aspire Empowerment - A single .cs file runs an entire complex microservices application

Future Ecosystem Landscape

When properly implemented, this ecosystem will form:

• C# → The preferred language for learning and work
• GitHub → The largest source code hosting platform
• NuGet → The largest tool distribution platform
• Windows → The largest application and service platform

Important

Any application that can be written in C# should ultimately be written in C#. Any program that can run on .NET should ultimately run on .NET.

🤖 Strategic Value Four: Core Competitiveness in the AI Era

Current AI development ecosystems heavily depend on Python, with user-facing tools often choosing Node.js, and enterprise development gradually shifting to Java due to significant inertia. However, .NET possesses underestimated competitive advantages in AI development.

.NET's Competitive Advantages in AI

Advantage Dimension	Specific Value
Performance	Clear advantages over Python and Node.js
Type Safety	Significantly reduces runtime errors in large-scale AI projects
Document Processing	Rich library support for PDF, Word, Excel handling
Aspire	Simplifies service configuration, built-in telemetry support (fundamental for AI applications)
Single-File Execution	Can be embedded in workflows, such as running .cs scripts directly in skills scenarios
First-Party Support	Microsoft services provide official .NET SDK support

When .NET SDK becomes an operating system component, these advantages will be more easily discovered and utilized by developers, promoting .NET's adoption in AI development.

💰 Low Cost, High Return

The cost for Microsoft to integrate .NET SDK into the operating system is relatively low. Windows already has a .NET update mechanism; the only requirement is to package and pre-install .NET SDK as a system component.

Viable Implementation Plan:

1. Windows 11 Monthly Updates - Beginning with the next prepared version, distribute .NET 10 SDK as an optional feature in monthly updates that users can choose to install
2. Annual Update Strategy - In November monthly updates each year, install the latest .NET SDK version while preserving previous versions

Benefits Analysis:

• Increased developer ecosystem engagement
• Enhanced Windows competitiveness as a development platform
• Growth in .NET market share in emerging fields like AI and cloud-native development
• Overall enhancement of Microsoft's technology stack competitiveness

📣 Take Action Now

If you believe in the vision of "Making .NET Great Again," participate through the following means:

Community Voice:

• GitHub - Like and comment on "system-level .NET SDK" proposals in Microsoft's dotnet and vscode repositories
• Social Media - Share your thoughts about .NET's future on X, LinkedIn, and other platforms using #DotNetFuture2026
• Tech Communities - Participate in discussions on Microsoft forums, .NET Foundation mailing lists, and Discord communities

Content Creation:

• Write blogs and create videos promoting this vision
• Create more related content combining this article with your own perspectives
• Generate greater impact and drive decision-making

Important

Not pre-installing .NET on Windows is like Windows not pre-installing Edge browser or Android not pre-installing Chrome browser—utterly baffling, essentially hamstringing itself!

Excuses for Inaction

I can already anticipate that some will find various reasons to oppose this idea, making excuses and offering so-called politically correct rationales, such as:

• "This will increase Windows size": Simply remove some obsolete system components and make room for .NET SDK.
• "Users don't need or care about .NET SDK": This reverses cause and effect. Regardless of how many users you claim to represent, provide it first, then discuss whether users need or care about it.
• ".NET Core is open-source and cross-platform, why bundle it on Windows": This argument is unworthy of refutation because cross-platform compatibility doesn't conflict with pre-installation on Windows. Linux has pre-installed PHP and Python tools for over a decade, and their popularity benefited greatly from pre-installation. Such arguments are merely excuses from those unwilling to see .NET succeed. Then simply pre-install on mainstream Linux distributions as well.
• "Consider version compatibility, multiple versions coexistence, and update issues": Anyone who has used .NET Core SDK knows these aren't problems. .NET Core natively supports multiple versions coexisting, and version management is straightforward. If Windows can maintain .NET Framework, why not .NET Core?

Listen more to actual users' voices, less to those spouting only "political correctness" from non-target users. Take more practical action and do things truly beneficial to ecosystem development.

Tip

You can leverage this article's content combined with your own perspectives to create more related content and promote this vision.

[KalleOlaviNiemitalo]

• Goodbye to Script Files - Replace ps1/bash scripts and CI/CD scripts with .cs, eliminating the need to learn multiple scripting syntaxes, just one .cs file

Running a file-based application for the first time is pretty slow (but dotnet caches the results within the temp directory):

$ echo '_ = 0;' > empty2.cs
$ time dotnet ./empty2.cs

real    0m2,548s
user    0m0,000s
sys     0m0,047s
$ time dotnet ./empty2.cs

real    0m0,742s
user    0m0,015s
sys     0m0,047s

The dotnet first-time execution is slower than PowerShell, for which there are already complaints (PowerShell/PowerShell#6443, PowerShell/PowerShell#14268, microsoft/terminal#217 (comment)):

$ time pwsh -c ''

real    0m0,980s
user    0m0,000s
sys     0m0,093s

and much slower than CMD:

$ time MSYS2_ARG_CONV_EXCL="*" cmd /C ""

real    0m0,082s
user    0m0,000s
sys     0m0,047s

Key Advantage: No need for version management tools; multiple versions can be installed simultaneously without interference.

There is an upcoming version-management tool dotnetup, e.g. #51579.