.NET Conf 2026 Day 1: .NET 11, C# 15 Unions, and Faster Builds
.NET 11 shipped on Tuesday. If you missed the .NET Conf 2026 live stream because you had actual work to do, you’re in good company. So did I.
I had an agent watching the stream for me all day (I wrote up how I livetweeted .NET Conf without watching all of it), and it left me with hours of notes and screenshots. This article is the cleaned-up version of Day 1: what shipped, what’s still in preview, and which numbers came with fine print.
These notes come from AI transcription of the live stream plus screenshots of what was on screen. I’ve kept every number tied to the benchmark or demo it came from. If a speaker walked something back later in the session, the correction is what you’ll read here.
The short version
- .NET 11 is GA, and C# 15 brings unions, closed hierarchies, collection expression arguments, labeled
breakandcontinue, and extension indexers. - The keynote showed 66% to 75% faster startup for selected CLI commands, and C# Dev Kit’s BuildX took a single-change build of the Aspire repo from 36.1 seconds to 2.1 seconds.
- Runtime async is opt-in. Its synchronous-completion benchmark allocated 0 bytes per operation, compared with 216 to 504 bytes for compiler-generated state machines.
- ASP.NET Core added header-based CSRF protection, with roughly 4x the form-post throughput of token validation.
- MAUI moved to CoreCLR on every supported platform.
- Aspire’s TypeScript AppHosts are GA, and Go is in preview for Aspire 17.
- Barry Dorrans reported 2,622 MSRC cases and 97 CVEs for 2026, up from 84 cases and 12 CVEs in 2025.

C# 15 unions
In What’s new in C#, Mads Torgersen and Dustin Campbell showed what unions change in ordinary code.
They started with a List<object> holding unrelated types. Every switch over it needs a catch-all arm, because the compiler has no idea what could be in there. Swap that for a union, and the compiler knows the full set of possible types. Now it can tell you when your switch misses a case.

From the session:
- The cases can be types from libraries you don’t own. They don’t need a shared base class.
- The compiler generates a struct for the union. You can also implement the union pattern yourself, including storage that avoids boxing value types.
- Closed hierarchies solve the same problem for inheritance. A public
closedclass only allows direct inheritance inside its own assembly, so the compiler can check your switches for exhaustiveness.
The session also covered collection expression arguments (handy for passing comparers), labeled loop exits, and extension indexers. If you liked C# 14 extension members, extension indexers fill in the next obvious gap. The new memory safety rules were shown separately as a preview.
Faster CLI, faster loads, faster builds
A lot of Day 1 was about making the inner loop shorter.
Chet Husk’s Moving dotnet Ahead (of Time)! walked through compiling the CLI with Native AOT. On his macOS arm64 machine, dotnet --version dropped from about 118 ms to 33 ms. dotnet tool list --local dropped from 121 ms to 32 ms.

The AOT work has a size cost. Moving tool-command resolution into AOT added 2.19 MiB to the SDK while saving roughly 100 ms per tool execution. The team offset that with SDK-wide deduplication that saved 53 MB in the compressed Linux x64 SDK.
In C# Dev Kit 11, Drew Noakes and Emanuel Fernandez Dell’Oca showed shared project caches and a build system that knows the difference between rebuilding a project, copying its outputs, and skipping it entirely. Warm workspace loads for the Roslyn repo went from 89.0 seconds to 15.9 seconds. Aspire went from 87.9 to 19.9.

On the 407-project Aspire solution, BuildX cut a single-change build from 36.1 seconds to 2.1 seconds, and a no-change build from 34.4 seconds to 0.9 seconds. Those are medians of five runs on the session’s Windows machine. With the shared cache, the IDE can reuse work that an agent or another build already did.
Husk came back later for More Processes, More Problems: Multithreaded MSBuild. The -mt switch cuts process overhead and still works with existing tasks. The OrchardCore numbers in this session and the keynote came from different machines, so they don’t match.
| OrchardCore benchmark | Keynote, Windows | MSBuild session, Windows | MSBuild session, Linux |
|---|---|---|---|
| Cold full build | 104.7 to 92.4 s, 12% less | 116.05 to 88.74 s, 23.5% less | 96.15 to 84.74 s, 11.9% less |
| Warm incremental build | 28.4 to 17.9 s, 37% less | 54.58 to 17.36 s, 68.2% less | 25.47 to 22.13 s, 13.1% less |
Multithreaded builds are still opt-in. The team is targeting SDK 11.0.200 to make them the default.

ASP.NET Core and Blazor
Daniel Roth’s Modern web development with ASP.NET Core & Blazor in .NET 11 opened with header-based CSRF protection. It uses the Fetch Metadata headers browsers already send, with an Origin header fallback. Compared with token validation, the slide showed about 4x the form-post throughput and 65% less allocation. Your existing antiforgery middleware still works alongside it.

SignalR can now refresh authentication without reconnecting. In the Blazor demo, revoking a permission updated an open page and kept everything the user had typed. One caveat Roth made sure to call out: the refresh runs on an interval near token expiration. The demo used a short interval. Permission changes aren’t pushed to the client the instant they happen.
C# unions showed up again, this time in API contracts. System.Text.Json serializes the active case, and OpenAPI 3.2 describes the options with anyOf. Shared async validation runs in both Blazor forms and Minimal APIs. And a WebAssembly demo moved CPU-heavy work to a .NET Web Worker so the UI stayed responsive.
Roth also shared production numbers from MSN: 29% lower P95 GC pauses, 11% lower async plugin latency, and 20% shorter thread-pool queues. Those came from moving .NET 8 to .NET 10, so they’re about the upgrade path in general and not .NET 11 specifically.
WinForms and MAUI
The WinForms post was my most-viewed post of the conference.
Klaus Löffelmann demoed the new .NET 11 visual styles mode on existing controls. The app picked up the Windows accent color, honored text-size settings, supported dark mode and toggle switches, and used a form-reveal setting to kill the white flash on startup. There are also new designer analyzers that give coding agents diagnostics to fix designer code they generate.

Gerald Versluis’s What’s New in .NET MAUI in .NET 11 covered the move to CoreCLR on Android, iOS, Mac Catalyst, and Windows. XAML source generation is on by default. C# expressions in XAML cover a lot of cases where you used to write a converter. And an Avalonia backend adds Linux and WebAssembly targets in preview.
The keynote led with “2.4x faster Native AOT startup.” The dedicated session had the device-level details. On a Pixel 5 running Android 14, the BaristaNotes sample started in a median of 973.5 ms with full ReadyToRun and 280.0 ms with Native AOT. That was a .NET 11 RC2 benchmark with 1,000 drinks and 30 launches per configuration. On an iPhone 15 Pro, it was 490 ms versus 322 ms. Android Native AOT is still experimental.

Jonathan Peppers closed the day with Bringing dotnet run, test, and watch to .NET MAUI. Pick a device, and dotnet run installs the app, launches it, and streams the logs. Hot Reload runs over WebSockets. New Android and iOS test templates run tests on the device through Microsoft.Testing.Platform. A cross-platform mauitest template is coming from the experimental MAUI Labs work.

AI in the app and in the tools
Luis Quintanilla’s .NET AI Stack session used a media-production app to cover model calls, document extraction, speech, image generation, and agent-driven UI. The official OpenAI and Anthropic SDK integrations both expose IChatClient, and a new RoutingChatClient picks the model for each request based on policy.

The app mixed cloud and local providers. One example: an IImageGenerator implementation asked a chat model to write SVG and then rendered it to PNG. Microsoft Agent Framework handled orchestration, and AG-UI plus the experimental Blazor AI components connected the agent to editable app state.
Wendy Breiding’s Beyond Autocomplete chased a duplicate purchase-order bug across a WinForms UI in Visual Studio, an ASP.NET Core API in VS Code, and a reporting task in the Copilot app. The agents passed a handoff document between them, and .NET skills supplied task-specific guidance. NuGet packages can also ship skills that come down during restore.
The skills evaluation dashboard was the most-saved post I made all week. It reports results per model, including the inconclusive ones. The C# expert skill with Claude Sonnet 5 used 41% fewer tokens and finished 73% faster, for that model and that skill. Don’t read it as a blanket claim about every model or task.

Aspire 17
In What’s New in Aspire for .NET Developers, Maddy Montaquila and Damian Edwards previewed Aspire 17, due the following week. AppHosts become plain Microsoft.NET.Sdk projects, so upgrading is a package bump. Project references by path let the dashboard start without waiting on the full MSBuild graph. And you can attach a debugger to an app that’s already running.

Montaquila and Jose Perez Rodriguez came back later to explain how Aspire supports other AppHost languages. Exported C# APIs produce a shared contract and generated guest SDKs, and the calls run against a .NET host over JSON-RPC. TypeScript is GA. Go is in preview for Aspire 17. Python, Java, and Rust are behind feature flags.
They ran a TypeScript AppHost with Node and Vite apps on a fresh WSL install with no .NET SDK installed. The dashboard was a custom Blazor build compiled with Native AOT: startup went from 1,429 ms to 491 ms, and deployment size (runtime included) dropped from 183 MB to 110 MB. That was a custom build done with the Blazor team. Don’t go expecting your Blazor Server app to compile with Native AOT just yet.

Runtime async, memory safety, and numerics
Andy Gocke and Richard Lander’s .NET Runtime vNext explained the runtime async opt-in. You write the same C# async code, and the runtime handles the work that used to live in compiler-generated state machines. The team expects it to become the default in .NET 12.
In the synchronous-completion benchmark, going from three to seven async frames gave speedups of 1.06x to 1.13x. Allocations dropped from 216 to 504 bytes per operation down to zero. An eight-frame exception benchmark showed 2.5x faster handling without suspension and 3.4x faster with suspension.

Memory safety rules v2 are a preview in .NET 11, with GA expected in .NET 12. They make unsafe contracts explicit at the call site. Lander turned them on in his own project and found unnecessary unsafe code that an AI agent had added.
Tanner Gooding’s .NET 11 Numerics introduced IEEE 754 decimal floating-point types: Decimal32, Decimal64, and Decimal128, with 7, 16, and 34 significant digits. Generic Complex<T> lets you pick the numeric representation. Tensor optimizations produced some big wins on specific operations. The dense float Add benchmark went from 16.37 microseconds to 0.114 microseconds.

Security
Barry Dorrans’s 2 Secure 2 Curmudgeonly reported a sharp increase. MSRC cases went from 84 to 2,622. CVEs went from 12 to 97. Bounties went from $635,500 to $1,012,500. Dorrans credited the jump to researchers using AI to dig through existing code.

The examples were specific implementation bugs: repeated certificate construction, missing validation at native-code boundaries, bad assumptions about span APIs, and malformed HTTP/2 input. In one case, a 117 KB SignedCms message triggered about 160,000 certificate constructions. The fix parses it once.
Jeremy Barton’s Post-Quantum Cryptography with .NET 11 covered Composite ML-KEM (ML-KEM paired with a traditional algorithm, so an attacker has to break both) and HPKE support under RFC 9180. More ML-KEM integration with HPKE and Composite ML-KEM in EnvelopedCms are planned for .NET 11 servicing.

Session replays
Times are the scheduled ET times. Each session title links to the start of that session in the Day 1 replay.
| Time (ET) | Session | Speakers |
|---|---|---|
| 12:00 PM | C# 15 unions and closed hierarchies | Mads Torgersen, Dustin Campbell |
| 12:30 PM | ASP.NET Core and Blazor | Daniel Roth |
| 2:00 PM | The .NET AI Stack | Luis Quintanilla |
| 3:00 PM | C# Dev Kit 11 | Drew Noakes, Emanuel Fernandez Dell’Oca |
| 3:30 PM | Multithreaded MSBuild | Chet Husk |
| 6:00 PM | Aspire’s language support | Maddy Montaquila, Jose Perez Rodriguez |
| 6:30 PM | Runtime async and memory safety | Richard Lander, Andy Gocke |
| 7:30 PM | MAUI run, test, and watch | Jonathan Peppers |
What caught your eye?
Day 2 was all about Visual Studio, Blazor resilience, and AI workflows. Read my .NET Conf 2026 Day 2 recap next.
What are you most excited to try in .NET 11? Hit me up on X, Bluesky, or LinkedIn.

About Kevin
Kevin Griffin has been running production .NET applications and teaching developers for over two decades. A 17-time Microsoft MVP specializing in ASP.NET Core and Azure, Kevin brings real-world experience from his own SaaS products alongside his consulting work at Swift Kick. He's hosted the Hampton Roads .NET User Group since 2009 and founded RevolutionVA, the nonprofit behind Hampton Roads DevFest. Kevin's talks blend hard-won lessons from production systems with practical advice you can use Monday morning.