Reading · Sebastian Gingter

April was the kind of month where the headlines could have come out in any order and you would still have called it a busy one.

.NET 11 Preview 3 landed and pushed Runtime Async out of the preview gate. Microsoft Agent Framework 1.0 went GA and finally answered the “which AI abstraction do I commit to” question that has been hanging over the .NET ecosystem for the better part of two years. April Patch Tuesday brought six CVEs across the supported runtimes, including a remote code execution issue that you really do not want to sit on. The Critter Stack hit its 2026 milestone with both Wolverine and Marten doing a flurry of releases. And Visual Studio’s April update made one small change to Copilot that, judging by my own reaction, a lot of people have been quietly waiting for.

Let me walk through what actually mattered.

.NET 11 Preview 3: Runtime Async leaves the preview gate

The headline in Preview 3 (shipped April 14) is that Runtime Async no longer requires the preview-API opt-in. The feature is not done yet, but it is no longer hiding behind an experimental flag in your project file. That is the kind of step that signals the team is comfortable with the shape of the API, not just the implementation underneath.

If you have been following along since Preview 1 and 2, this is the natural next move. Runtime Async has been the most quietly significant story in the .NET 11 cycle, and Preview 3 keeps building on it. JIT optimizations get another pass: better switch processing, smarter bounds check elimination, improved cast operations. Browser and WebAssembly continue to get attention with WebCIL support and improved debugging.

On the libraries side, a few items stood out:

Zstandard compression moved into System.IO.Compression. ZIP reads now validate CRC32. The compression story is gradually becoming what you would expect a modern runtime’s compression story to look like.
Regex now recognizes all Unicode newline sequences. Boring on the surface, useful when you actually deal with text from the wider world.
Container images are now digitally signed. That is a supply chain improvement that does not need much commentary. Just a quiet “good”.

The ASP.NET Core side picks up Zstandard for both response compression and request decompression, and the Virtualize component now adapts to variable-height items at runtime. That last one is one of those features that sounds boring until you have actually fought a virtualized list with mixed-height rows in a real application. Then it stops being boring.

HTTP/3 also kicks off request processing earlier, which trims latency in the path that matters most for HTTP/3 in the first place: the long-tail connection setup time.

And in MAUI, the Maps control finally gets clustering, richer styling, and proper interaction APIs. LongPressGestureRecognizer is built in. Android 17 / API 37 is in preview support. The MAUI story keeps tightening, slowly but visibly.

File-based apps grow up

The SDK side of Preview 3 is small but, if you have been using dotnet run file.cs, genuinely welcome.

File-based apps can now span multiple files. dotnet run -e lets you pass environment variables straight from the command line. dotnet watch got Aspire support, crash recovery, and Windows desktop improvements. Solution filters can now be edited from the CLI.

The single-file program feature was useful from day one for scripts and one-off prototypes. The minute you wanted to split anything into a second file, though, you were back to creating a project. Removing that hard ceiling is exactly the right move. The whole point of file-based programs is to lower the barrier between “I have an idea” and “I have running code”. Forcing a project boundary the moment you reach for a second file undermined that.

Small change. Right direction.

C# 15 in Preview 3: union types get the IDE polish

The big C# 15 story was already told in March: union types landed in Preview 2. Preview 3 is the polish pass.

The Visual Studio editor now actually understands them in the 2026 Insiders build. Tooling support is what turns a language feature from an interesting spec into something you can use without fighting your own IDE. If you have been waiting to play with union types because the editor experience was rough, this is the moment to give them another look.

The runtime piece still has caveats. Some of the supporting BCL plumbing is not in place yet, and union member providers from the proposal did not make it into Preview 2 or 3. So this remains preview territory in the proper sense of the word. But every preview release pulls more of the feature into a shape you can actually evaluate against your real code.

I keep reading takes on union types that frame them as a niche addition. They are not. One-of-N values are everywhere in real code (parsers, result types, message contracts, workflow states), and every workaround we have built over the years (abstract base classes, discriminated records, smart-type wrappers) was apologizing for the language. Union types stop the apologizing.

EF Core 11 Preview 3: less ceremony, faster queries

EF Core 11 Preview 3 is small but well-targeted.

ChangeTracker.GetEntriesForState() is the one I will probably use first. It returns tracked entities in a specific state without forcing a DetectChanges() pass. In long-lived contexts (or anywhere you do high-volume change tracking and already know the states you care about) avoiding that pass is real. It is not just a micro-optimization. It removes a side-effect from a query that most people forget is there in the first place.

RemoveDbContext() and RemoveExtension() are aimed squarely at testing scenarios. Replace your production SQL Server registration with an in-memory or SQLite provider for a test? You can now do that cleanly instead of dancing around the existing configuration. This is the kind of API that exists because someone on the team got tired of seeing the same workaround in everyone’s test setup.

SQL generation eliminates more unnecessary JOINs, particularly around optional navigation properties, and SQL Server gets new JSON APIs. The vector story changes shape too: SqlVector properties are no longer loaded by default. You have to project or load them explicitly. That is the right default. Vector columns are big, and pulling them on every query just because they exist on the entity is exactly the kind of thing that shows up in a slow-query audit six months later.

Migrations get better control and clearer feedback. Microsoft.Data.SqlClient updates to 7.0.0. Nothing flashy. Just a release that makes EF Core a little less surprising on the edges.

Microsoft Agent Framework 1.0 went GA, and this one is a real story

This is the one I think most people will look back on as the actual headline of April.

On April 3, Microsoft Agent Framework reached 1.0 for both .NET and Python. Production-ready, stable APIs, versioned releases, with a long-term support commitment. Open source. The GA release explicitly positions itself as the unification of Semantic Kernel and AutoGen into a single SDK.

That last sentence is the important one.

If you have been building anything serious with AI in .NET over the last two years, you have lived through the fragmentation. Semantic Kernel was the enterprise-focused option. AutoGen was the multi-agent orchestration playground. Microsoft.Extensions.AI showed up as the abstractions layer. MCP landed as the integration protocol. Each of these had a real reason to exist, and each of them required you to make a bet on which abstraction was going to be the long-term one. That bet was hard to make confidently because nobody, including Microsoft, had finished thinking it through.

Agent Framework 1.0 is the version where that thinking is finished, and the answer is: this one.

What is in 1.0:

Single agent and service connectors for Microsoft Foundry, Azure OpenAI, OpenAI, Anthropic Claude, Amazon Bedrock, Google Gemini, and Ollama
Middleware hooks across the agent execution pipeline
Pluggable agent memory and context providers
Graph-based agent workflows with composable agents and functions
Multi-agent orchestration patterns: sequential, concurrent, handoff, group chat, and Magentic-One
Declarative agents and workflows in YAML
A2A and MCP support for cross-runtime collaboration and external tool integration

Migration guides exist for both Semantic Kernel and AutoGen. That is not just paperwork. It tells you that the team understands they are asking people to consolidate, and they are taking on the responsibility of making that easier.

My take is unambiguous: if you are starting a new AI-heavy project in .NET, this is the abstraction to build on. If you are already invested in Semantic Kernel or AutoGen, plan the migration this year. Not because the old frameworks will fall over tomorrow, but because the place where energy and investment are going to land is now clear, and that always matters more than the current state of the API surface.

April Patch Tuesday: this one is mandatory

April 14 brought .NET 10.0.6, 9.0.15, and 8.0.26 along with .NET Framework cumulative updates. Six CVEs across the supported runtimes:

CVE-2026-23666 — DoS in .NET Framework 3.0–4.8.1
CVE-2026-26171 — Security feature bypass in .NET 10/9/8 and Framework
CVE-2026-32178 — Remote code execution in .NET 10/9/8 and Framework
CVE-2026-32203 — DoS in .NET 10/9/8 and Framework
CVE-2026-32226 — DoS in Framework 2.0–4.8.1
CVE-2026-33116 — Remote code execution in .NET 10/9/8

Two RCEs in a single servicing release is not a number you negotiate with. If you are running anything on supported .NET in production, this is a get-current-now release. Not “this sprint”, not “in the next change window”. Now.

The fact that the Framework side is also getting hit (with a critical DoS at CVSS 7.5) is a reminder that the long tail of .NET Framework deployments is still very much in scope for security maintenance. If you have systems that “we just have not gotten around to migrating yet”, they are not standing still in the threat-model sense. They are accumulating exposure.

Visual Studio 2026 April update: Copilot finally yields to IntelliSense

The April update for Visual Studio 2026 (18.5.0, with 18.5.1 following on April 21) had one change that I suspect a lot of people will quietly bless: IntelliSense now wins the completion race against Copilot.

When IntelliSense is active, Copilot completions are suppressed. When you commit or dismiss the IntelliSense selection, Copilot resumes. That is it. That is the change.

The reason this matters is not that Copilot completions are bad. It is that the conflict between two completion systems trying to occupy the same UI surface at the same moment was genuinely annoying for anyone who knew exactly which member they were trying to call. You knew the name. IntelliSense knew the name. Copilot was off proposing something that may or may not have been what you wanted, and the wrong Tab press could land you in either world. Letting IntelliSense own the precise completion path while Copilot owns the open-ended suggestion path is exactly the right division of labor.

The rest of the April update leans further into agentic workflows: cloud agent sessions launch from the IDE, custom agents now have user-level support, and a new debugger agent can validate proposed fixes against actual runtime behavior. JSON Editor picked up Draft 2019-09 and 2020-12 schema support, which closes a real gap if you live anywhere near OpenAPI, JSON Schema, or modern config formats.

The point worth highlighting is that this is what monthly IDE updates are supposed to look like: real improvements, not visual rearrangement.

The Critter Stack reached its 2026 milestone

April was an enormous month for JasperFx. Wolverine alone shipped four releases (5.28, 5.29, 5.30, 5.31), then kept going through 5.34. Marten ended the month at 8.34. Jeremy Miller’s retrospective post framed these as the symbolic completion point for the current major versions, with new feature work shifting to Marten 9, Wolverine 6, and Polecat 3.

A few things from this batch deserve a callout.

Wolverine got gRPC support, contributed by Erik Shafer. If you operate in a polyglot environment where gRPC is already part of the transport story, this removes another integration boundary. Messaging interop is one of those features that sounds dry on a release page and saves you days of work the first time you actually need it.

Marten added PostgreSQL Row-Level Security support for multi-tenancy. Multi-tenant data isolation in PostgreSQL is a problem that teams routinely build themselves, badly, before realizing how much edge case there really is. Having this as a first-class library feature is genuinely valuable.

Wolverine’s ProjectLatest API lets you project aggregates including pending uncommitted events. That is a small change with surprisingly high practical value if you live in event-sourced systems and have wrestled with the read-after-write window.

The other theme is cold start performance and AOT compliance. Both projects are explicitly focused on being viable in serverless deployments. JasperFx.RuntimeCompiler is being moved toward development-only status rather than a runtime requirement. That is the kind of architectural decision that does not show up in a feature list but determines whether your library can run in environments people actually care about today.

The Critter Stack has been one of the more interesting stories in the .NET ecosystem for a while. April is the month where you can see the pattern clearly: deliberate, fast-paced, and now plotting the move to a runtime profile that matches where workloads are going.

What April was, really

Preview 3 made .NET 11 feel a little more shaped. Agent Framework 1.0 ended a long stretch of “which AI abstraction should I commit to” uncertainty. The April CVEs were the unglamorous reminder that supported runtimes earn their keep through patching. Visual Studio got a small Copilot fix that matters more than it sounds. And the Critter Stack closed out its 2026 milestone and started preparing for the next major versions.

The previews are interesting. The GA release is the one that changes plans. The patches are the one that keeps you running.

All three happened this month.

.NET News April 2026