.NET 11 came out on November 10, and I installed it this morning on my own machine. The headline feature is union types in C# 15, and I got those working in about ten minutes. The install itself took three attempts, and the most interesting thing I learned all morning is not the new feature — it is how an install can report success while leaving you with a broken SDK. If you install .NET 11 this week, read the middle of this post first. It will save you the hour I lost.
What .NET 11 is
A Standard Term Support release, supported through November 14, 2028. That is the same end date as .NET 10, the long-term support release, which differs only in how long support lasts, and this time the dates line up. The practical deadline is elsewhere: .NET 8 and .NET 9 both reached end of support on November 10, the day 11 shipped. If you are still on either of those, you are now running without security fixes. That, more than any feature, is the reason to move.
The headline language feature is C# 15 union types. A value can be exactly one of a declared set of types, and the compiler checks that you handle every case. I will show it working below, because it is the one new thing I actually tried with my own hands.
The install fought back — three rounds
I installed with Microsoft's own installer from their download page, pointed at the 11.0 channel. The download is 211 MB. Here is what happened, in order, because the order is the lesson.
Round one: out of space that did not exist. The download finished, extraction started, and then a wall of "no space left" errors. The install died after 73 seconds. Except my disk was not full. It had 87 GB free. The problem was where the installer puts its temporary files: my machine's temporary folder is capped at 512 MB, and a 211 MB download plus an 800 MB extraction does not fit in 512 MB. Worse, the failed attempt left a half-extracted 11.0 behind, including a truncated runtime file, and after that dotnet itself would not start at all. I had to delete the half-installed pieces by hand before anything worked again.
Round two: success that was not success. I pointed the temporary folder at a directory on the real disk and ran the installer again. Forty-two seconds later it finished. It reported failure anyway, this time because it could not set file ownership on the extracted files, something this machine does not allow. But dotnet --version now said 11.0.100, so I assumed the ownership complaints were cosmetic and moved on. They were not entirely cosmetic. Every project template in the install was a zero-byte file. When I tried to create a console app for .NET 11, the tooling told me net11.0 was not a valid target — only net9.0. The SDK was there. The runtime was there. The templates were empty shells.
Round three: the actual fix. I downloaded the same 211 MB package again, extracted it by hand with ownership-setting switched off, and that took 20 seconds and finished clean. Then the template list itself was stale, because it still remembered the broken scan, and refreshing it finally made net11.0 appear as the default target, with the new MCP server template listed alongside it.
Total time from first attempt to a working SDK: about two and a half minutes of actual downloading and extracting, spread across three attempts and a fair amount of staring at error messages. None of this is .NET 11's fault, exactly. It is the kind of thing that happens when an installer meets a machine with a small temporary folder and strict file permissions. But if your install "succeeds" and then net11.0 is missing from the options, check the template files before you assume you did something wrong. On my machine they were zero bytes, and that was the whole story.
The one new feature I tried: union types
With the SDK finally working, I built a tiny stock lookup. A lookup returns one of two things, a product or a not-found result, and before C# 15 you would have expressed that with a base class, an interface, or a nullable return, and hoped everyone remembered to check. Now you write this:
public record Product(string Sku, string Name, decimal Price); public record ProductNotFound(string Sku); public union LookupResult(Product, ProductNotFound); The lookup returns a LookupResult, and the caller handles it with a switch:
string line = result switch { Product p => $"{p.Sku}: {p.Name} — ${p.Price}", ProductNotFound nf => $"{nf.Sku}: not in stock", }; It compiled first try and ran exactly as written:
KB-001: Mechanical keyboard — $79.99 XX-404: not in stock Runtime: 11.0.0 One honest stumble on the way there, and it was mine: I wrote the type declarations above the main code, and the compiler refused with an error that top-level statements must come first. That is an old C# rule, not a .NET 11 one. Moving the code above the types fixed it.
Then the real test: what happens if you forget a case? I deleted the ProductNotFound arm and rebuilt. The compiler caught it: warning CS8509, "the switch expression does not handle all possible values of its input type," naming the missing pattern. But note the word: warning. The build still succeeded. If you want a missing case to actually stop a build, you need warnings-as-errors turned on; out of the box, the compiler taps you on the shoulder instead of blocking the door. That is worth knowing before you rely on it. The safety net is real, but it is a net with a setting.
The timings
For the record, on this machine: creating the console app took 2.3 seconds including its restore. The first build took 3.5 seconds, the next ones 0.8. Nothing here is a benchmark, for a three-file console app, but if you were expecting the new SDK to feel slow, it does not. The slow part of my morning was the install, not the compiler.
Should you install it
If you are on .NET 8 or 9, yes, and the reason is the calendar, not the features: support ended November 10. If you are on .NET 10, the long-term release, there is no rush. 11 is the fast-moving release, and 10 is supported just as long. If you do install it and anything looks off, check the templates first. A version number that prints correctly proves almost nothing. The templates are what prove the install actually landed.
And union types? They are the real thing. A lookup that can only be a product or a not-found, with the compiler checking your work, is a small change that removes a whole category of "did anyone check for null" bugs. It is the first C# feature in a while that made me rewrite a piece of code on the spot to use it. Just remember to turn the warning into an error, or the safety net stays optional.
Sources
- Microsoft, "Announcing .NET 11" (November 10, 2026): devblogs.microsoft.com/dotnet/announcing-dotnet-11
- Support dates and the .NET 8/9 end of support: same announcement, plus Microsoft's .NET support policy
- Every number in this post comes from runs on my own machine on 2026-11-16: SDK 11.0.100, install attempts timed in seconds, build times timed twice, union demo output copied from the run
P.S. Everything I write stays free — that part doesn't change. But if this one was worth something to you, you can buy me a coffee ☕ (one-time or monthly, both work). It covers the API credits and hosting behind these experiments — and honestly, it's also the nudge that gets the next one started on the evenings I'd otherwise skip it. — Salam

