<!-- mobian-agent-page publisher="dailydev" canonical="https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59" -->

---
title: .NET 11 Just Got Cleaner Call Stacks! | daily.dev
description: A preview feature called runtime async v2, shipping in .NET 11 RC1, changes how the CLR handles async/await so that the compiler no longer rewrites async...
canonical: https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59
twitter:card: summary_large_image
twitter:site: @dailydotdev
og:type: website
og:site_name: daily.dev
og:title: .NET 11 Just Got Cleaner Call Stacks! | daily.dev
og:description: A preview feature called runtime async v2, shipping in .NET 11 RC1, changes how the CLR handles async/await so that the compiler no longer rewrites async...
og:url: https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59
og:image: https://api.daily.dev/og/posts/V3oV6Np59.png
og:image:alt: .NET 11 Just Got Cleaner Call Stacks!
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 Just Got Cleaner Call Stacks!

**[We Are .NET](https://daily.dev/sources/wearedotnet)** · 5 min read · 2 upvotes · 0 comments

## Summary

A preview feature called runtime async v2, shipping in .NET 11 RC1, changes how the CLR handles async/await so that the compiler no longer rewrites async methods into generated state machine types implementing IAsyncStateMachine. Instead, the runtime itself manages suspension and resumption, producing live call stacks where methods like outer, middle, and inner async appear as adjacent frames instead of being interrupted by compiler-generated infrastructure. A side-by-side demo comparing identical C# async code running on .NET 10 and .NET 11 shows the .NET 10 stack trace cluttered with four compiler-generated state machine frames, while the .NET 11 version with runtime async enabled shows zero state machine types via reflection and a clean call chain. Three caveats are highlighted: the feature is still in preview as of .NET 11 RC1 (September 2026), frame totals aren't guaranteed to be identical across environments (documentation cites a 13-vs-5 frame example), and exception stack traces shouldn't be used for this comparison since they already get async cleanup via exception dispatch info.

## Full article

daily.dev links to this article rather than hosting it. Read it at the original source: <https://www.youtube.com/watch?v=nUBz02E2mco>

## Questions this post answers

### What is runtime async in .NET 11 and how does it change call stacks?

Runtime async v2 is a preview feature in .NET 11 (available in the 11 RC1 build) that makes async a runtime concept instead of a compiler trick. The compiler emits an async method implementation directly rather than rewriting the method into a generated state machine type implementing IAsyncStateMachine, so live call stacks show application frames like outer, middle, and inner adjacent to each other instead of interrupted by compiler-generated MoveNext and async method builder infrastructure.

_Track how .NET 11's async internals evolve before adopting runtime async in production debugging workflows, with daily.dev._

### Does .NET 11's runtime async remove state machine types entirely?

Yes, with runtime async v2 enabled, reflection finds zero compiler-generated async state machine types for methods compiled under it, compared to .NET 10 where the same async call chain produces four separate state machine types (one per async method). The async implementation flag replaces the previous attribute-based approach, and thread pool frames beneath the application chain remain normal.

_Developers comparing .NET 10 and .NET 11 async internals can follow debugging changes like this on daily.dev._

### Are the improved call stack frame counts in .NET 11 runtime async guaranteed to be consistent?

No, frame totals are not 100% guaranteed to be identical across environments. Documentation for runtime async v2 gives an example showing 13 frames versus 5 frames on a fast-path sample, since operating system, runtime build configuration, and continuation location can all affect the totals; developers should focus on the application frame chain rather than exact counts, and should avoid comparing caught exception traces since those already get async cleanup via exception dispatch info.

_Keep up with preview-stage .NET runtime behavior like this before it lands in a stable release, 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
- [.NET 11 Performance Gains That Matter for AI-Adjacent Backends — Daily DevOps & .NET](https://daily.dev/posts/net-11-performance-gains-that-matter-for-ai-adjacent-backends-daily-devops-net-25rrsf53j) · Daily DevOps & .NET · 28 upvotes · 2 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-just-got-cleaner-call-stacks--v3ov6np59)

```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 Just Got Cleaner Call Stacks!","url":"https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59"},"datePublished":"2026-09-18T19:05:37.914Z","dateModified":"2026-09-18T19:06:01.434Z","description":"A preview feature called runtime async v2, shipping in .NET 11 RC1, changes how the CLR handles async/await so that the compiler no longer rewrites async...","image":"https://i.ytimg.com/vi/nUBz02E2mco/sddefault.jpg","thumbnailUrl":"https://i.ytimg.com/vi/nUBz02E2mco/sddefault.jpg","isAccessibleForFree":true,"articleSection":"We Are .NET","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":"We Are .NET","logo":"https://media.daily.dev/image/upload/s--BsnVOa3i--/f_auto/v1718347410/logos/wearedotnet","url":"https://daily.dev/sources/wearedotnet"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":2},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":".net,c#","timeRequired":"PT5M","video":{"@type":"VideoObject","name":".NET 11 Just Got Cleaner Call Stacks!","description":"A preview feature called runtime async v2, shipping in .NET 11 RC1, changes how the CLR handles async/await so that the compiler no longer rewrites async...","thumbnailUrl":"https://i.ytimg.com/vi/nUBz02E2mco/sddefault.jpg","uploadDate":"2026-09-18T19:05:37.914Z","duration":"PT5M","url":"https://api.daily.dev/r/V3oV6Np59","embedUrl":"https://www.youtube.com/embed/nUBz02E2mco"}}
{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"We Are .NET","item":"https://daily.dev/sources/wearedotnet"},{"@type":"ListItem","position":3,"name":".NET 11 Just Got Cleaner Call Stacks!"}]}
{"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/net-11-just-got-cleaner-call-stacks--v3ov6np59#faq","mainEntity":[{"@type":"Question","name":"What is runtime async in .NET 11 and how does it change call stacks?","acceptedAnswer":{"@type":"Answer","text":"Runtime async v2 is a preview feature in .NET 11 (available in the 11 RC1 build) that makes async a runtime concept instead of a compiler trick. The compiler emits an async method implementation directly rather than rewriting the method into a generated state machine type implementing IAsyncStateMachine, so live call stacks show application frames like outer, middle, and inner adjacent to each other instead of interrupted by compiler-generated MoveNext and async method builder infrastructure. Track how .NET 11's async internals evolve before adopting runtime async in production debugging workflows, with daily.dev."}},{"@type":"Question","name":"Does .NET 11's runtime async remove state machine types entirely?","acceptedAnswer":{"@type":"Answer","text":"Yes, with runtime async v2 enabled, reflection finds zero compiler-generated async state machine types for methods compiled under it, compared to .NET 10 where the same async call chain produces four separate state machine types (one per async method). The async implementation flag replaces the previous attribute-based approach, and thread pool frames beneath the application chain remain normal. Developers comparing .NET 10 and .NET 11 async internals can follow debugging changes like this on daily.dev."}},{"@type":"Question","name":"Are the improved call stack frame counts in .NET 11 runtime async guaranteed to be consistent?","acceptedAnswer":{"@type":"Answer","text":"No, frame totals are not 100% guaranteed to be identical across environments. Documentation for runtime async v2 gives an example showing 13 frames versus 5 frames on a fast-path sample, since operating system, runtime build configuration, and continuation location can all affect the totals; developers should focus on the application frame chain rather than exact counts, and should avoid comparing caught exception traces since those already get async cleanup via exception dispatch info. Keep up with preview-stage .NET runtime behavior like this before it lands in a stable release, via daily.dev."}}]}
```

