Quick Answer: The .NET 11 runtime raises the minimum CPU baseline to x86-64-v2 and, on Windows, to Arm64 with the LSE instruction set. It also adds preview Runtime Async, which moves async state handling into the runtime, plus cleaner live stack traces, faster async continuations, and JIT improvements for bounds checks and switch expressions.
If you run .NET on a machine bought in the last decade, you probably won't notice the new hardware floor. If you run it on an old lab box, a spare desktop, or a small Arm64 board, you might find your app won't start at all. That's the first thing to check in Microsoft Learn's .NET 11 runtime notes, and it's the one most upgrade guides skip. The runtime changes below are real, but they arrive with trade-offs you should plan for before you upgrade.
Note that the page was last updated at release candidate 2. Treat the specifics as provisional and confirm them against the final release notes.
The hardware floor moved, and .NET 11 won't limp along
The most common advice about runtime upgrades is that older hardware keeps working, just slower. That's no longer true for .NET 11. The runtime now requires more modern instruction sets, and if the CPU is missing one of them, the process fails at startup with a message saying the current CPU is missing one or more baseline instruction sets.
On x64, the baseline moves from x86-64-v1 to x86-64-v2 on all three operating systems. That adds CX16, POPCNT, SSE3, SSSE3, SSE4.1, and SSE4.2 to the guaranteed set. Microsoft's reasoning is that Windows 11 already requires these, and that all x86/x64 CPUs still supported by Intel and AMD have them. The last older chips fell out of support around 2013.
| OS | New JIT/AOT minimum | New ReadyToRun target | What changed |
|---|---|---|---|
| Apple | x86-64-v2 / Apple M1 | x86-64-v2 / Apple M1 | Minimum raised on x64; R2R unchanged |
| Linux | x86-64-v2 / armv8.0-a + LSE | x86-64-v3 / armv8.0-a + LSE | Minimum raised; R2R raised on x64 |
| Windows | x86-64-v2 / armv8.0-a + LSE | x86-64-v3 / armv8.2-a + RCPC | Minimum raised; R2R raised on both architectures |
The table shows why the change matters more than the version bump suggests. The R2R column is the ahead-of-time code shipped with your assemblies. Raising that target means the precompiled code can use AVX2, BMI2, and FMA, which is faster. It also means a machine just below the new bar may fall back to JIT compilation, which costs startup time.
Arm64 is where the surprises are
Arm64 has a counter-intuitive trap. On Linux, the JIT minimum didn't change, so a Raspberry Pi-class device that only offers AdvSimd still runs. But the ReadyToRun target now includes LSE, the Large System Extensions atomic instructions. On a device without LSE, the precompiled code doesn't match the hardware, so the runtime jits more code at launch. Your app still works, but cold starts can get slower. This is the cause-and-effect chain to remember: a higher R2R target improves steady-state speed on modern chips and adds startup cost on older ones.
Windows is stricter. The baseline now requires LSE, which Windows 11 needs and which the Arm SBSA specification expects. Apple M1 stays the reference point, and the source describes it as roughly armv8.5-a, with AdvSimd, CRC, DOTPROD, LSE, RCPC, RCPC2, and RDMA. For Apple, nothing changes on the Arm64 side.
Here's where most migration plans go wrong: teams test on their developer laptops, which are newer than the fleet. Check the actual CPUs in production, including containers on older cloud instances, before you trust a clean test run.
Runtime Async is a preview, and the opt-in is simpler now
Runtime Async (Runtime Async V2) is the bigger architectural change. Instead of the compiler generating a state-machine class for every async method, the runtime tracks suspension and resumption itself. That's the reason the stack traces look different, and it's why profilers and debuggers see fewer synthetic frames.
It's still a preview feature. To opt in, add this to your project file:
<PropertyGroup>
<Features>runtime-async=on</Features>
</PropertyGroup>
A net11.0 project no longer needs <EnablePreviewFeatures>true</EnablePreviewFeatures>. Two other changes matter if you're scripting builds. The DOTNET_RuntimeAsync and UNSUPPORTED_RuntimeAsync environment variables have been removed. To opt a single project out, set <UseRuntimeAsync>false</UseRuntimeAsync> in its project file. If your CI pipeline relied on the environment variables, change it before you upgrade, or your toggle will silently stop working.
The runtime libraries themselves are compiled with runtime-async enabled, and they no longer contain compiler-generated state machines. That means an app whose dependencies are all libraries can migrate as a whole. Microsoft is asking for reports, positive or negative, on throughput and library size. Measure both on your own workload before you rely on either.
Cleaner stack traces make live debugging faster
The most visible win is what you see during execution. Compiler-generated async adds a frame for each state machine plus infrastructure frames from AsyncMethodBuilderCore.Start. In the source's three-method example, a new StackTrace() taken from the innermost method showed 13 frames. With Runtime Async, the same call chain shows 5 frames: InnerAsync, MiddleAsync, OuterAsync, Main, and the entry point.
That difference matters when you're reading a profiler flame graph or a logging dump under load. The real call path is easier to read, and breakpoints in async methods bind correctly. The debugger can also step across await boundaries without dropping into generated infrastructure.
One caveat: exception stack traces from catch (Exception ex) already looked the same with or without Runtime Async, because existing ExceptionDispatchInfo cleanup handles them. Don't expect a change in your error logs. The improvement applies to live execution, not to exceptions you've already caught.
Performance work: continuations, tail awaits, and skipped context capture
Runtime Async brings several performance changes. The JIT now compiles a dedicated runtime-async version of a synchronous, task-returning method instead of routing through a thunk. It turns tail calls into runtime-async calls, which removes an extra layer of indirection. Hot async methods also flow through tiered compilation, so they reach tier 1 after warm-up. Cached continuations, reuse of continuation objects, and skipped saves of unchanged locals all cut allocation pressure in async-heavy code.
The change that applies to more code, even without Runtime Async, is the ExecutionContext work. ExecutionContext carries ambient state such as AsyncLocal<T> values across await points. Previously, every Task continuation captured and restored that snapshot, even when nothing had changed. The runtime now detects when there's nothing to restore and skips the cycle. This applies to Task, Task<T>, ValueTask, and ValueTask<T>.
Don't assume you'll see a large gain. The benefit is biggest in high-throughput code that uses ConfigureAwait(false) and has little AsyncLocal<T> state. If your app relies heavily on ambient context, the saving is smaller, and you should benchmark instead of guessing.
Here's a related point most guides miss: the JIT also recognizes common factories such as Task.FromResult, Task.CompletedTask, and ValueTask.FromResult, and folds them into faster paths. Code that returns completed tasks in hot paths gets the most out of this.
JIT improvements to bounds checks and switch expressions
Outside async, the JIT gets a few targeted improvements. It now eliminates bounds checks for the pattern where an index plus a constant is compared against a length, such as i + cns < len. It also removes more redundant checks for index-from-end access, such as values[^1]. In tight loops over arrays and spans, these remove checks you were already paying for without thinking about them.
The JIT can also prove that some checked arithmetic contexts are already in range and remove the overflow checks. Multi-target switch expressions can fold into simpler branchless checks when the targets allow it. The source doesn't publish benchmark numbers for these, so measure your own hot loops before you claim a gain in a report.
Frequently Asked Questions
what's new in .NET 11 for the runtime?
The .NET 11 runtime raises the minimum x64 baseline to x86-64-v2 and, on Windows, requires the Arm64 LSE instruction set. It adds preview Runtime Async, which moves async state management into the runtime. It also brings cleaner live stack traces, skipped ExecutionContext capture for continuations, and JIT changes to bounds checks and switch expressions.
how do I enable runtime async in .NET 11?
Add <Features>runtime-async=on</Features> to a PropertyGroup in your project file. On net11.0 you don't need EnablePreviewFeatures. To opt a single project out, set <UseRuntimeAsync>false</UseRuntimeAsync>. The old DOTNET_RuntimeAsync environment variable no longer has any effect.
why does .NET 11 fail on older CPUs?
.NET 11 requires instruction sets such as SSE4.2 and POPCNT, which were added to x64 CPUs over the last decade. If the processor is missing one of the baseline sets, the runtime refuses to start and prints an error about the baseline. Check your hardware against the table above before you upgrade production servers.
does runtime async make my app faster?
Not automatically. Runtime Async reduces overhead in async code, and it can cut allocations and improve tier 1 optimization for hot methods. The gains depend on your workload, and the feature is still a preview. Benchmark your own app with it on and off, and report regressions to the .NET team.
Test the upgrade before you trust the headline
The single most actionable step is to check your hardware baseline before anything else. Run a test on the oldest CPU in your fleet, not the newest laptop, and confirm the app starts and that cold-start time is acceptable. Then enable Runtime Async on a non-critical service and compare throughput, allocations, and library size against a baseline. Pass this to whoever owns your deployment images, because a CPU mismatch will fail at startup, not during your tests.