What's new in the .NET 11 runtime

.NET 11’s runtime changes, especially moving async/await machinery into the runtime for clearer stack traces and comparable performance, are being welcomed as a significant quality-of-life improvement for developers. Commenters contrast C# and .NET’s rich language features, tooling, and ecosystem—particularly for back-end and enterprise work—with Go and TypeScript, while also highlighting ongoing pain points like GUI cross‑platform options, mobile support, and Microsoft’s LTS/STS upgrade cadence and breaking changes. There is also interest in .NET’s potential as an AI- and agent-friendly platform, alongside concern over subtle behavioral shifts such as new decimal conversion semantics.

Runtime async changes & performance

  • Big interest in .NET 11 moving async/await machinery into the runtime.
  • Expected benefits: clearer live async call stacks in debuggers/profilers, more “natural” stack traces, potentially fewer hitches during cancellation.
  • Clarified that exception stack traces already hid much of the compiler-generated state-machine frames; main win is for live debugging.
  • Coroutines remain stackless; yielding becomes a runtime-aware operation, not just compiler rewriting.

C#/.NET vs Go and other languages

  • Many compare .NET 11 + C# to Go for new projects:
    • C# seen as more expressive: LINQ, attributes, richer generics, async/await, pattern matching, reflection, records, Span, source generators.
    • Go praised for small binaries, simple syntax, fast compiles, strong stdlib, built-in HTTP server, goroutines, opinionated tooling.
  • Native interop considered easier in .NET overall, though UTF‑16 vs UTF‑8 string marshalling is a pain point; UTF‑8 literals in C# 11 help.
  • Opinions differ on concurrency: some prefer C# async/await for typical I/O, others prefer Go’s goroutines/channels; a subset argues F#+Hopac is nicer still.
  • Several see Go’s limited feature set as a feature; others criticize its generics history, stringly-typed tags, and error-handling ergonomics.

Tooling, ecosystem, and deployment

  • .NET praised for “batteries-included” ecosystem, robust libraries, and strong IDE tooling (Visual Studio, Rider, VS Code).
  • Go credited with a better default single-binary deployment story; .NET single-file/AOT still uneven with some libraries.
  • For enterprise apps, .NET is seen as fast, mature, and widely staffed; Go viewed as great for smaller tools and services.

Cross-platform, GUI, and mobile

  • Ongoing frustration with Microsoft’s desktop UI story: many competing frameworks (WinForms, WPF, UWP, WinUI, MAUI), unclear long-term bets, and weak Linux/macOS support.
  • Some recommend third-party frameworks like Avalonia for cross-platform GUIs; others stick to web or Electron/TypeScript for products.
  • Mobile support via MAUI is viewed as not yet solid, especially on Linux.

Language evolution & sum types

  • Excitement that C# 11 finally gets a form of sum types with exhaustive switch checking; still not full discriminated unions.
  • A proposal for proper discriminated unions is under active design; some want easier “value object”/newtype support to approach F# ergonomics.

Decimal and numeric behavior changes

  • .NET 11 changes conversions from floating-point to decimal to preserve the exact binary value, exposing non‑terminating decimals (e.g., (decimal)0.1 now shows a long repeating-ish representation).
  • Some see this as a dangerous footgun for financial apps; others argue the previous magic rounding was wrong and that casting from double to decimal is bad practice anyway.
  • Recommended approach in discussion: use decimal consistently and decimal literals (0.1m) rather than casting from double/float.

Support model, version churn, and breaking changes

  • .NET 11 is STS (2 years) vs even-numbered LTS releases (3 years); support timelines for .NET 10 and 11 end in 2028, with STS expiring slightly earlier.
  • Some find STS/LTS distinctions confusing or weak compared to ecosystems like Java; others note it’s well-documented and similar to Node’s even/odd model.
  • One strong criticism: yearly releases + breaking changes + short support windows effectively force constant upgrades and threaten long-term library stability.
  • Counterpoints: old libraries targeting earlier TFMs still work; many apps happily remain on .NET 8/Framework; Microsoft isn’t literally forcing upgrades, though security tooling nudges you.

AI, agents, and “AI-native” .NET

  • Several argue C#/.NET is an excellent “AI-era” stack:
    • Stable toolchain, strong typing, rich analyzers (Roslyn), good docs, predictable patterns.
    • Agents can leverage tools like csharprepl injected into running processes/DI to inspect and modify live state.
  • Others lament that, in practice, AI tooling and ecosystems favor Python, Rust, and TypeScript, and that C# failed to gain mindshare in AI despite Microsoft’s efforts.
  • F# is reported to work surprisingly well with AI code generation; good, idiomatic F# backends have been built largely by agents.

Perception, culture, jobs, and IDEs

  • Many feel C#/.NET is underappreciated due to legacy Windows-only perceptions, past tech deprecations (WCF, Silverlight, AppFabric), and mistrust of Microsoft.
  • Despite that, there’s lots of “dark matter” C# in enterprises (e.g., healthcare, ERPs); work is often stable but can feel boring.
  • For editors/IDEs on Linux/macOS, Rider and VS Code are the main recommendations; some still use full Visual Studio on Windows.
  • A number of participants say modern LLMs plus simpler editors reduce the need for heavyweight refactoring tools.