Microsoft pushed out .NET 11 Release Candidate 2 on October 13, 2026, and two days later followed it with a smaller but arguably stickier announcement: a new command-line tool called dotnetup. Together, the two releases answer two very different questions developers have been asking for years. One is “what’s new in the next .NET,” and the other is “why do I still have to fight my operating system just to install an SDK.” Microsoft’s .NET team updated the RC2 announcement page as recently as October 17, 2026, and the company’s own documentation now points to a general availability target of November 2026 for .NET 11, keeping the platform on the same annual November cadence it has followed since .NET 5 unified the Framework and Core lineages.
Neither release is flashy in the way a new AI model drop is flashy. There’s no headline benchmark score, no single “it’s 10x faster” claim to anchor a press cycle around. But for the millions of developers who build on .NET every day, and for the enterprises that depend on it for everything from banking backends to point-of-sale systems, RC2 and dotnetup are the kind of incremental, plumbing-level changes that quietly shape how software actually gets built. This piece breaks down what shipped, what it means for teams already running .NET workloads, and where the platform is likely headed once GA lands next month.
Don't miss new tech stories on Google
Add Tech Insider once in the Google app and our stories appear in your news suggestions.
What Shipped This Week: .NET 11 RC2 and dotnetup, at a Glance
Release Candidate 2 is, as the name implies, the second of two release candidates Microsoft typically ships before a final .NET version goes GA. According to Microsoft’s devblogs post, RC2 carries a go-live license, meaning the company is telling teams it is stable enough to run in production ahead of the final release. That’s standard practice for .NET release candidates, but it matters here because it signals Microsoft’s confidence that the remaining weeks before GA will be about polish rather than structural change.
The RC2 build touches a long list of areas across the .NET stack: the core libraries, the runtime itself, the SDK, MSBuild, NuGet, F#, ASP.NET Core, .NET MAUI, and Windows Forms all received updates in this release. Microsoft recommends developers testing RC2 install the latest Visual Studio 2026 Insiders build on Windows, though the release candidate also works with Visual Studio Code and the C# Dev Kit extension on any supported platform. That dual-path support, full IDE and lightweight editor, reflects how much of the .NET developer base has shifted toward cross-platform workflows over the last several release cycles.
dotnetup, announced separately on October 15, 2026, is described by Microsoft as a public-preview toolchain manager. Its job is narrow but important: install, manage, and update .NET SDKs and runtimes entirely within a developer’s own user account, without needing administrator rights and without touching the system-wide .NET directory that previous installers relied on. Microsoft’s initial framing targeted macOS and Linux developers specifically, and the tool’s own documentation describes it as cross-platform, capable of installing stable releases, preview builds, daily builds, and exact pinned versions.
Inside .NET 11 Release Candidate 2: What Changed
Microsoft’s RC2 notes don’t lead with a single marquee feature the way some past .NET releases have. Instead, the update reads like a checklist of continued investment across the stack. The libraries and runtime improvements in RC2 build on changes introduced in earlier .NET 11 previews throughout 2026, while the SDK, MSBuild, and NuGet updates focus on build and dependency-resolution reliability rather than new user-facing capability. ASP.NET Core, .NET MAUI, and Windows Forms all picked up fixes and refinements as part of the same release train, which is typical of how Microsoft handles the back half of a .NET release cycle: front-load the big language and runtime bets in early previews, then spend the release candidates stabilizing everything that touches them.
What Microsoft’s public materials do not yet confirm, at least in the RC2 announcement itself, are specific performance numbers. There’s no published benchmark showing RC2 is some percentage faster than .NET 10 or earlier .NET 11 previews. That’s worth flagging explicitly, because past .NET releases, particularly .NET 7 and .NET 8, leaned heavily on headline performance claims tied to independent web framework benchmarks and internal JIT improvements. The absence of a similar number in the RC2 cycle so far suggests Microsoft may be saving performance messaging for the GA announcement in November, when the full release notes typically include a fuller before-and-after comparison.
| Component | Status in .NET 11 RC2 | Primary Audience |
|---|---|---|
| .NET Runtime | Updated, part of RC2 go-live build | All .NET developers |
| Base Class Libraries | Updated alongside runtime changes | All .NET developers |
| .NET SDK | Updated, installable via official channel or dotnetup preview | All .NET developers |
| MSBuild | Updated for build reliability | Build and CI engineers |
| NuGet | Updated for dependency resolution | Package maintainers, app teams |
| F# | Updated as part of RC2 | F# developers |
| ASP.NET Core | Updated as part of RC2 | Web and API developers |
| .NET MAUI | Updated as part of RC2 | Cross-platform mobile/desktop teams |
| Windows Forms | Updated as part of RC2 | Windows desktop teams |
C# 15 Arrives With .NET 11: New Language Features
C# 15 ships as the default language version for any project targeting .NET 11, continuing the pattern where a new major C# version rides along with each annual .NET release. Microsoft’s language documentation names several specific features landing in C# 15, including collection expression arguments, union types, closed hierarchies, extension indexers, and labeled break and continue statements. There’s also a dedicated push around memory safety and a preview of an updated unsafe-code model, which Microsoft describes as removing “everyday ceremony” from common code patterns.
Union types are the feature most likely to generate discussion among .NET developers who have watched languages like TypeScript, Rust, and Kotlin build entire type systems around sum types and discriminated unions. C# has approximated the pattern for years using class hierarchies and pattern matching, but a more native union type construct would close a gap that has pushed some teams toward F# or external libraries just to get the same expressiveness. Closed hierarchies serve a related purpose: they let a developer tell the compiler that a type hierarchy is complete and will not be extended outside its defining assembly, which enables more exhaustive pattern-matching checks at compile time.
Extension indexers extend C#’s existing extension member system, letting developers add indexer syntax (the square-bracket access pattern used on arrays and dictionaries) to types they don’t own. Labeled break and continue statements solve a smaller but genuinely annoying problem: escaping or continuing an outer loop from inside a nested loop without resorting to goto statements or boolean flag variables, a complaint that has shown up in C# language-design discussions for years.
Meet dotnetup: Microsoft’s Answer to a Decade-Old Developer Pain Point
If C# 15 is about expressiveness, dotnetup is about friction. Anyone who has worked across multiple .NET projects on the same machine knows the problem dotnetup is trying to solve: the official .NET installers put SDKs and runtimes into shared, system-level directories, which means installing or removing a version typically requires administrator privileges and can affect every other project on the box. Developers who need to juggle .NET 8, .NET 9, and .NET 10 side by side for different clients or services have had to rely on manual PATH management, Docker containers, or third-party version-switching scripts to avoid stepping on each other’s toes.
dotnetup moves SDK and runtime installation into the user’s own account. According to Microsoft’s documentation, it tracks what it installs so that related files can later be updated or removed cleanly, and it supports installing stable releases, preview builds, daily builds, and exact pinned version numbers. That last capability matters most for teams testing against release candidates like .NET 11 RC2 itself: a developer can pull a specific preview build with dotnetup, test against it, and remove it without disturbing whatever stable SDK version the rest of their machine depends on.
Microsoft has been explicit that dotnetup is still public preview software, which means its commands, options, and long-term support plan could change before it reaches general availability. The initial framing from Microsoft’s devblogs specifically called out macOS and Linux developers as the target audience, which lines up with the reality that Windows already has more mature tooling for this kind of SDK juggling through Visual Studio’s installer and workload manager, while Unix-like platforms have historically leaned on community scripts.
How dotnetup Compares to Version Managers in Other Ecosystems
Every major language ecosystem has eventually grown its own user-local version manager, usually because the official installer wasn’t flexible enough for developers running multiple projects at different version requirements. Node.js developers have long used nvm, Python developers rely on tools like pyenv, and Rust ships with rustup as an officially blessed, first-party version manager built into the language’s own tooling story from early on. .NET has lagged behind on this specific front, partly because the .NET SDK’s own multi-targeting support inside a single project reduced some of the pressure, and partly because Visual Studio’s installer handled a lot of version management for Windows-first teams.
| Tool | Ecosystem | Admin Rights Required | Status |
|---|---|---|---|
| dotnetup | .NET | No (user-local) | Public preview, October 2026 |
| rustup | Rust | No (user-local) | Official, first-party, stable for years |
| nvm | Node.js | No (user-local) | Community-maintained, widely adopted |
| pyenv | Python | No (user-local) | Community-maintained, widely adopted |
The comparison matters strategically. Rust’s rustup has been credited by many in that community as one of the reasons the language’s tooling reputation improved so quickly after its early years, because it removed an entire category of onboarding friction. Microsoft building a first-party equivalent for .NET, rather than leaving the gap to community tools, suggests the .NET team sees SDK management as a developer-experience metric worth owning directly rather than outsourcing to the ecosystem. It’s a similar instinct to what’s driving faster build tooling elsewhere in the industry right now, including the kind of throughput gains chased by projects like Bun’s newer TypeScript checker in the JavaScript world.
.NET’s Annual Release Cadence: Historical Context
To understand why RC2 and dotnetup landed when they did, it helps to understand Microsoft’s release rhythm. Since .NET 5 merged the old .NET Framework and .NET Core lines in 2020, Microsoft has shipped a new major .NET version every November, like clockwork. Each release candidate cycle runs through the preceding summer and fall, with RC1 and RC2 builds arriving in the weeks before the November GA date. .NET 11 RC2’s mid-October arrival and its documented November 2026 GA target fit squarely inside that established pattern, which is itself a deliberate predictability play: enterprise .NET shops can plan upgrade cycles, testing windows, and staffing around a release date they’ve known for years in advance.
That predictability stands in contrast to the pace of change elsewhere in the developer tools world right now, where AI-assisted coding tools and editors are shipping major updates on a near-weekly basis. .NET’s steady, almost boring release cadence is arguably a feature for the kind of large, risk-averse organizations that depend on the platform for mission-critical systems, even as it can look slow next to faster-moving frameworks. The same tension shows up in how newer web frameworks like TanStack Start have pushed hard on rapid iteration as a selling point.
Visual Studio 2026 Insiders and VS Code: Where RC2 Runs Today
Developers who want to try .NET 11 RC2 today have two realistic entry points. On Windows, Microsoft points teams toward the latest Visual Studio 2026 Insiders build, which gets RC2 support ahead of the stable Visual Studio channel. On any other platform, or for developers who simply prefer a lighter editor, Visual Studio Code with the C# Dev Kit extension provides the same RC2 compatibility without requiring the full Visual Studio install.
That split mirrors a broader shift happening across the editor landscape, where VS Code’s extension model has become the default on-ramp for trying new language and runtime previews, even for ecosystems historically associated with a single heavyweight IDE. It’s the same dynamic playing out in the Java world, where JetBrains has had to defend IntelliJ IDEA’s position as VS Code-based tooling gains ground, a trend covered in detail around JetBrains’ own Java language server push into VS Code and Cursor earlier this year.
Market Impact: What This Means for Enterprise .NET Shops
For the enterprise teams that make up much of .NET’s installed base, banks, insurers, retailers, and government systems among them, RC2 itself is unlikely to trigger urgent action. Go-live licensing on a release candidate is a green light for early adopters, not a mandate for production teams already running stable .NET 10 or earlier versions. The more interesting signal for enterprise architecture teams is dotnetup, because SDK and runtime version sprawl is a real operational cost in large .NET shops running dozens or hundreds of services across different .NET generations.
A user-local, no-admin-rights installer has direct implications for how IT departments manage developer machines. Many enterprise environments lock down local administrator rights for security reasons, which has historically made it harder for individual developers to install or switch .NET SDK versions without going through a ticketing process or an IT-managed image update. If dotnetup matures past preview with full support across Windows, macOS, and Linux, it could meaningfully cut the operational overhead of multi-version .NET development inside exactly the kind of locked-down corporate environments where .NET is most heavily used.
There’s also a build and CI angle. MSBuild and NuGet improvements bundled into RC2 matter less for day-to-day coding and more for the automated pipelines that enterprise teams run thousands of times a day. Any reliability improvement in dependency resolution or build consistency compounds quickly at that scale, even when the individual change looks minor in a release note.
Competitive Landscape: .NET vs Java, Node.js, and Python Tooling
.NET doesn’t operate in isolation, and this release cycle makes that clearer than usual. Oracle’s Java platform has been on its own aggressive cadence, and the recent Java 27 release leaned on explicit heap-usage and JEP-count messaging to make its case to enterprise buyers. Microsoft’s RC2 announcement, by contrast, reads more like a stabilization update than a competitive pitch, at least until the numbers-heavy GA release notes presumably arrive in November.
On the web framework side, ASP.NET Core’s updates inside RC2 arrive while JavaScript-ecosystem frameworks keep pushing throughput and server-rendering performance as their main differentiator, as seen in comparisons like Hono, Express, and Fastify’s recent throughput gap. .NET’s web stack has historically competed well on raw performance benchmarks, but Microsoft’s decision not to lead RC2’s messaging with a performance number leaves that comparison open for now. Python’s tooling story, where version management has long depended on community tools layered over the official interpreter, looks the most similar to where .NET sat before dotnetup, and offers a rough preview of the kind of adoption curve a first-party .NET version manager might expect to follow if developers trust it the way the Python community eventually trusted pyenv.
The Road to General Availability in November 2026
With RC2 in hand and a November 2026 GA target on Microsoft’s own documentation, the remaining window for .NET 11 is short. Historically, the gap between RC2 and GA in past .NET release cycles has run just a few weeks, with Microsoft using that stretch to fix regressions reported by early adopters running the go-live build in real projects rather than to introduce new features. Teams evaluating .NET 11 for a near-term production upgrade should expect the final GA build to closely resemble RC2 in behavior, with the main open questions being exactly which bug fixes land and whether Microsoft publishes the performance benchmarks that were notably absent from the RC2 announcement itself.
dotnetup’s timeline is less predictable, precisely because it’s explicitly public preview rather than tied to the .NET 11 release train. Microsoft has given no committed date for dotnetup reaching general availability, and the tool’s documentation itself warns that commands, options, and behavior may still change. Developers adopting it today should treat it the way most teams treat any public preview tool: useful for testing and experimentation, but not yet something to build critical infrastructure automation around without a fallback plan.
Risks and Open Questions Ahead of GA
A few open questions will shape how smoothly .NET 11 lands next month. First, Microsoft hasn’t yet clarified whether .NET 11 will carry long-term support (LTS) or standard-term support (STS) status, a distinction that directly affects how long enterprise teams can run it before being forced to upgrade again. Microsoft has alternated LTS and STS designations across recent even- and odd-numbered releases in the past, so the classification for .NET 11 is a meaningful detail enterprise planners will want confirmed at GA.
Second, dotnetup’s full platform matrix isn’t yet fully documented. Microsoft’s initial dotnetup announcement called out macOS and Linux developers specifically, and while the tool’s own documentation describes it as cross-platform, it hasn’t been explicitly confirmed whether Windows support ships at the same preview stage or arrives later. For an enterprise base that remains heavily Windows-centric, that gap could limit how quickly dotnetup gets tested inside larger organizations.
Third, the absence of published performance figures for RC2 leaves a gap in the public narrative that competitors in the Java and JavaScript ecosystems have been quick to fill with their own numbers. Whether that’s a deliberate choice to save the number for GA, or simply a reflection that this particular release cycle is more about stabilization than raw speed, will become clear once the final release notes publish in November.
Predictions: What to Watch Through Early 2027
- GA ships close to RC2: Expect .NET 11’s November 2026 general release to closely mirror RC2’s feature set, with Microsoft using the final weeks for regression fixes rather than new capability.
- Performance numbers arrive at GA: Microsoft is likely to publish fuller benchmark comparisons against .NET 10 in the official GA announcement, filling the gap left by RC2’s release notes.
- dotnetup expands its platform matrix: Given the tool’s current focus on macOS and Linux, a Windows-inclusive update is a logical next step if Microsoft wants dotnetup to become the default .NET installation path across all platforms.
- C# 15’s union types spark ecosystem debate: Expect active discussion in the .NET community about how closely C# 15’s union types and closed hierarchies approach the ergonomics of languages like Rust and Kotlin, and whether library authors adopt the new constructs quickly or wait for broader tooling support.
- Enterprise dotnetup adoption lags behind individual developers: Public preview status and an unclear support lifecycle make it likely that individual developers and small teams experiment with dotnetup well before large enterprise IT departments formally approve it for managed developer machines.
How This Fits the Broader Developer Tools Moment
It’s worth placing this release inside the wider context of how developer tooling is evolving in late 2026. Editors, AI coding agents, and build systems are all competing for a developer’s attention and trust in ways that go beyond raw feature lists, and SDK installation friction is exactly the kind of unglamorous problem that can quietly push developers toward or away from a platform. The same instinct that produced tools focused on faster, safer code changes, like the work behind diff-based patch engines discussed in recent coverage of fast-apply patch engines, applies here: reducing the friction between “I want to try something new” and “I’m actually running it” is one of the highest-leverage things a platform team can ship, even when it doesn’t come with a flashy benchmark attached.
Microsoft’s own developer tooling strategy has leaned increasingly on meeting developers wherever they already work, whether that’s full Visual Studio, VS Code, or now a standalone command-line SDK manager that doesn’t require either. That multi-front approach echoes decisions by other platform teams betting on broader IDE compatibility and lightweight language-server strategy on real codebases.
Frequently Asked Questions
What is .NET 11 Release Candidate 2?
It’s the second of two planned release candidates for .NET 11, Microsoft’s next major .NET version, announced October 13, 2026 and carrying a go-live license that permits production use ahead of the final release.
When does .NET 11 reach general availability?
Microsoft’s own documentation points to a November 2026 GA target, consistent with the company’s annual November release cadence for .NET going back to .NET 5 in 2020.
What is dotnetup?
dotnetup is a public-preview command-line tool from Microsoft, announced October 15, 2026, that installs, manages, and updates .NET SDKs and runtimes locally within a developer’s own user account, without requiring administrator privileges.
Which platforms does dotnetup support?
Microsoft’s initial announcement focused on macOS and Linux developers, and the tool’s documentation describes it as cross-platform, though the full supported platform matrix, including the extent of Windows support, has not been explicitly detailed yet.
What’s new in C# 15?
C# 15, which ships as the default language version with .NET 11, adds collection expression arguments, union types, closed hierarchies, extension indexers, labeled break and continue statements, and a preview of an updated memory-safety-focused unsafe model.
Is .NET 11 RC2 safe to use in production?
Microsoft has issued RC2 under a go-live support license, meaning the company states it can be used in production applications, though it is still a pre-GA release candidate rather than the final version.
How do I try .NET 11 RC2 today?
On Windows, Microsoft recommends installing the latest Visual Studio 2026 Insiders build. On other platforms, or for a lighter setup, RC2 works with Visual Studio Code and the C# Dev Kit extension.
Does dotnetup replace the official .NET installer?
Not currently. dotnetup is a public-preview alternative installation path aimed at user-local, no-admin-rights SDK management, and Microsoft has not announced plans to deprecate its existing official installers.
