<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3" -->

---
title: .NET 11 runtime async: the runtime takes over await
description: .NET 11 lets the runtime suspend and resume async methods instead of the compiler generating a state machine. You opt in per project with...
canonical: https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: .NET 11 runtime async: the runtime takes over await | daily.dev
og:description: .NET 11 lets the runtime suspend and resume async methods instead of the compiler generating a state machine. You opt in per project with...
og:url: https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3
og:image: https://api.daily.dev/og/posts/ySJAQz1i3.png
og:image:alt: .NET 11 runtime async: the runtime takes over await
og:image:width: 1200
og:image:height: 630
og:locale: en
---

> ## Documentation Index
> Fetch the complete documentation index at: https://daily.dev/llms.txt
> Use this file to discover all available pages before exploring further.

# .NET 11 runtime async: the runtime takes over await

**[Meziantou](https://daily.dev/sources/meziantou)** · 7 min read · 7 upvotes · 0 comments

## Summary

.NET 11 lets the runtime suspend and resume async methods instead of the compiler generating a state machine. You opt in per project with `<Features>runtime-async=on</Features>`, and the runtime libraries already ship compiled this way. A sample async method compiles to 82 bytes of IL with ordinary locals and a `flags(2000)` marker, against 477 bytes for the `MoveNext` alone. Live stack traces show each method once instead of duplicated with `AsyncMethodBuilderCore.Start` frames, and breakpoints bind inside the real method instead of generated `MoveNext` code. The feature is still preview in .NET 11.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://www.meziantou.net/dotnet-11-runtime-async-the-runtime-takes-over-await.htm>

## Questions this post answers

### How do I enable runtime async in .NET 11?

Add the MSBuild property `<Features>$(Features);runtime-async=on</Features>` inside a `PropertyGroup` in the project file. This is a preview feature in .NET 11 that makes the runtime, instead of the compiler, suspend and resume async methods. The .NET runtime libraries themselves are already compiled this way regardless of whether a project opts in.

_Developers testing .NET 11 preview features can track async/await changes like this on daily.dev._

### What does the IL for an async method look like with .NET 11 runtime async enabled compared to the old compiler-generated state machine?

With runtime async, the method body is the original code (loops, locals, no state machine) marked with a `flags(2000)` metadata flag (MethodImplOptions.Async), and awaits compile to calls like `AsyncHelpers.Await` or `AsyncHelpers.UnsafeAwaitAwaiter`. One sample method shrank from a 477-byte `MoveNext` plus a hoisted-field state machine struct to just 82 bytes of IL, with locals staying as ordinary locals instead of becoming fields.

_Anyone sizing up the migration cost of .NET 11's new async model can find concrete IL comparisons like this on daily.dev._

### Does .NET 11 runtime async change what stack traces look like for async methods?

Yes, live stack traces show each async method exactly once, with no `AsyncMethodBuilderCore.Start` or state machine frames. Previously an async call chain duplicated each method name alongside builder frames. After a suspension completes, runtime async also removes the state machine and ExecutionContext frames between the resumed method and whatever completed the task, though the original callers are still not shown since they already returned.

_Developers debugging async stack traces can keep up with runtime changes like this via daily.dev._

## Similar posts on daily.dev

- [Runtime Async in .NET 11: What Actually Changed](https://daily.dev/posts/runtime-async-in-net-11-what-actually-changed-zpn3rqvrg) · C\# Corner · 16 upvotes · 0 comments
- [Microsoft Releases .NET 11 Preview 3 with Updates Across Runtime, SDK, MAUI, and ASP.NET Core](https://daily.dev/posts/microsoft-releases-net-11-preview-3-with-updates-across-runtime-sdk-maui-and-asp-net-core-4tyjhbtqm) · InfoQ · 5 upvotes · 1 comments

---

Tags: [#.net](https://daily.dev/tags/.net), [#c#](https://daily.dev/tags/c#)

[View this post on daily.dev](https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3)

```json
{"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]}
{"@context":"https://schema.org","@type":"TechArticle","headline":".NET 11 runtime async: the runtime takes over await","url":"https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3"},"datePublished":"2026-10-29T12:12:47.103Z","dateModified":"2026-10-29T12:13:17.255Z","description":".NET 11 lets the runtime suspend and resume async methods instead of the compiler generating a state machine. You opt in per project with...","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/4aa54394de88da5c4c7ea6e2d30917ba?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/4aa54394de88da5c4c7ea6e2d30917ba?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Meziantou","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Meziantou","logo":"https://media.daily.dev/image/upload/t_logo,f_auto/v1/logos/1bdfdd5349654b08ab6fa3f1ac38192c","url":"https://daily.dev/sources/meziantou"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":7},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":".net,c#","timeRequired":"PT7M"}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Meziantou","item":"https://daily.dev/sources/meziantou"},{"@type":"ListItem","position":3,"name":".NET 11 runtime async: the runtime takes over await"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/net-11-runtime-async-the-runtime-takes-over-await-ysjaqz1i3#faq","mainEntity":[{"@type":"Question","name":"How do I enable runtime async in .NET 11?","acceptedAnswer":{"@type":"Answer","text":"Add the MSBuild property `\u003cFeatures\u003e$(Features);runtime-async=on\u003c/Features\u003e` inside a `PropertyGroup` in the project file. This is a preview feature in .NET 11 that makes the runtime, instead of the compiler, suspend and resume async methods. The .NET runtime libraries themselves are already compiled this way regardless of whether a project opts in. Developers testing .NET 11 preview features can track async/await changes like this on daily.dev."}},{"@type":"Question","name":"What does the IL for an async method look like with .NET 11 runtime async enabled compared to the old compiler-generated state machine?","acceptedAnswer":{"@type":"Answer","text":"With runtime async, the method body is the original code (loops, locals, no state machine) marked with a `flags(2000)` metadata flag (MethodImplOptions.Async), and awaits compile to calls like `AsyncHelpers.Await` or `AsyncHelpers.UnsafeAwaitAwaiter`. One sample method shrank from a 477-byte `MoveNext` plus a hoisted-field state machine struct to just 82 bytes of IL, with locals staying as ordinary locals instead of becoming fields. Anyone sizing up the migration cost of .NET 11's new async model can find concrete IL comparisons like this on daily.dev."}},{"@type":"Question","name":"Does .NET 11 runtime async change what stack traces look like for async methods?","acceptedAnswer":{"@type":"Answer","text":"Yes, live stack traces show each async method exactly once, with no `AsyncMethodBuilderCore.Start` or state machine frames. Previously an async call chain duplicated each method name alongside builder frames. After a suspension completes, runtime async also removes the state machine and ExecutionContext frames between the resumed method and whatever completed the task, though the original callers are still not shown since they already returned. Developers debugging async stack traces can keep up with runtime changes like this via daily.dev."}}]}
```