website

🟦 Pulse on .NET – November 2025 Edition

Your AI-generated monthly roundup of .NET platform updates and community highlights.

November 2025 was a landmark month for .NET: Microsoft officially launched .NET 10 (LTS) – a major release emphasizing AI integration and performance – along with Visual Studio 2026. At the annual .NET Conf, we saw the debut of new AI-driven development tools (like GitHub Copilot’s modernization and testing features) and previews of next-gen frameworks such as the Microsoft Agent Framework for building intelligent apps. The community eagerly embraced the new releases, with open-source projects shipping day-one support (e.g. Uno Platform 6.4) and user groups worldwide celebrating .NET 10’s arrival. This edition of Pulse on .NET will recap the .NET 10 launch (its runtime, language, and framework enhancements), the accompanying tooling updates (IDE improvements and cloud integrations), the accelerated push for modernizing legacy .NET apps (now turbocharged by AI assistance and even support from AWS), the ecosystem news (open-source updates, community content, and events), and the expanded AI capabilities in .NET (from multi-agent frameworks to AI pair programming).

First, here’s a quick overview of November 2025’s key .NET announcements and their release dates:

Update	Release Date	Highlights	Source
.NET 10.0 (GA) – Long Term Support	November 11, 2025	Major release (LTS) – “most productive, modern, secure, intelligent, and performant .NET yet” [devblogs.m…rosoft.com]. Brings built-in AI support via new Microsoft Agent Framework and AI libraries [visualstud…gazine.com], [visualstud…gazine.com], significant performance gains (JIT optimizations, AVX10.2/SVE hardware accel., faster GC) [infoq.com], and C# 14 / F# 10 language updates (field-backed props, extension members, null-conditional assignment in C#; scoped warnings, parallel build in F#) [infoq.com], [infoq.com]. Includes improvements across ASP.NET Core (passkey auth, better OpenAPI, enhanced AOT), Blazor (faster load, state persistence), .NET MAUI (new controls, XAML compiler), and EF Core 10 (vector search, JSON columns) [infoq.com]. LTS supported for 3 years (until Nov 2028) [devblogs.m…rosoft.com], [infoq.com].
.NET 8.0.22 & .NET 9.0.11 (Servicing)	November 11, 2025	Patch updates for .NET 8 LTS and .NET 9 STS released alongside .NET 10. Contain non-security fixes only (October’s patches had already addressed critical vulnerabilities) [devblogs.m…rosoft.com]. No new features or breaking changes – these releases finalize .NET 8/9 stability for those not yet on .NET 10. .NET Framework had no new patches this month [devblogs.m…rosoft.com].
Visual Studio 2026 (GA)	November 11, 2025	Next-gen IDE now generally available, billed as the first “AI-powered” developer environment. Features full support for .NET 10 and C# 14, a refreshed Fluent UI, improved Hot Reload and Razor editors, and deep GitHub Copilot integration (AI “pair programmer” throughout the IDE) [devblogs.m…rosoft.com], [visualstud…gazine.com]. New Profiler AI Agents suggest performance fixes, Adaptive Paste auto-formats code, and a new solution file format (*.slnx) supports large modular repos [visualstud…gazine.com], [visualstud…gazine.com]. VS2026 emphasizes productivity and modernization (built-in upgrade tooling) while remaining seamlessly compatible with VS2022 projects.
GitHub Copilot Tools for .NET	November 11, 2025	AI-assisted dev enhancements announced at .NET Conf. Copilot App Modernization is now GA – an AI chat assistant that helps upgrade legacy .NET Framework apps to .NET 10, handling code fixes and config changes in minutes [devblogs.m…rosoft.com], [devblogs.m…rosoft.com]. Meanwhile, Copilot for Testing (Public Preview) can auto-generate unit tests and even suggest fixes for failing tests [devblogs.m…rosoft.com]. Early adopters reported significant time savings using these tools to modernize codebases [devblogs.m…rosoft.com]. Both features integrate into Visual Studio 2022/2026, underscoring how AI is accelerating .NET development and maintenance.
Uno Platform 6.4 & Uno Studio 2.0	November 11, 2025	Open-source UI framework Uno Platform released v6.4 with same-day .NET 10 and VS2026 support [infoq.com], plus a new emphasis on “agentic” AI-assisted development. The accompanying Uno Platform Studio 2.0 tool introduces a built-in Hot Design Agent – an AI assistant in the XAML designer that can suggest UI changes, re-layout controls, and even generate pages from prompts [infoq.com], [infoq.com]. Uno 6.4 also brings performance tweaks (off-UI-thread rendering, GPU-accelerated shadows) and support for VS2026’s new solution format [infoq.com], [infoq.com]. This release highlights community collaboration on .NET 10 (Uno helped implement Android 16 support in .NET MAUI) and how third-party frameworks are embracing AI to boost developer productivity.
Microsoft Agent Framework & MCP (Preview)	November 11, 2025	Debuted in Public Preview at .NET Conf, the Agent Framework enables building apps with multiple cooperating AI agents [visualstud…gazine.com]. It provides orchestration for sequential or parallel AI tasks, allowing agents to converse and hand off tasks (like a CHATGPT Plugin system for .NET). Paired with Model Context Protocol (MCP) support, agents can securely invoke external tools/APIs and share state [visualstud…gazine.com], [visualstud…gazine.com]. New templates let developers create MCP servers (exposing app capabilities to AI) [visualstud…gazine.com]. Together, these tools make .NET a first-class platform for agentic AI applications, extending .NET’s reach into autonomous workflows and intelligent assistants.

🔧 .NET 10 and Runtime Updates

.NET 10 (General Availability): On November 11, 2025, during the .NET Conf keynote, Microsoft officially released .NET 10.0 as a Long-Term Support (LTS) version. This is the first new LTS since .NET 8 in 2023 and is described as “the most productive, modern, secure, intelligent, and performant release of .NET yet”. Under the hood, .NET 10 includes thousands of improvements across the runtime, libraries, and SDK – with a dual focus on high performance and AI readiness. Key highlights include: [devblogs.m…rosoft.com]

• Performance Improvements: .NET 10 is the fastest .NET runtime to date. The JIT compiler received major upgrades like better inlining and devirtualization, plus new hardware intrinsics (Intel AVX10.2 and ARM64 SVE) to speed up math, cryptography, and machine learning workloads. Memory management is more efficient; for example, improved loop inversion and stack allocation strategies reduce GC pressure. Ahead-of-time compilation (NativeAOT) produces smaller, faster binaries than before. Many real-world scenarios see notable gains: Microsoft calls out .NET 10 as delivering “measurable reductions in memory usage and GC pauses” due to these changes. Internal benchmarks show big wins in JSON processing, compression, and more. In short, apps running on .NET 10 can expect to run faster and use less memory without any code changes, making performance a compelling reason to upgrade. [infoq.com] [theregister.com], [theregister.com]

• Language Updates (C# 14 and F# 10): .NET 10 ships with C# 14 and F# 10 out-of-the-box. C# 14 is a relatively small but useful update to the language, focusing on removing boilerplate and adding extensibility hooks. One standout feature is field-backed properties – you can now write properties that implicitly declare a backing field, allowing custom getters/setters without a manually defined field. This makes it easy to add logic to auto-properties (like trimming input) with cleaner syntax. C# 14 also introduces extension members (extension methods for static classes and even extension properties on types you don’t own), the ?.= null-conditional assignment operator, improved generic math via Span<T> implicit conversions, required members on structs, and more robust using aliasing. Collectively these features make C# “more expressive and maintainable”. On the functional side, F# 10 focuses on performance and simplicity: it adds scoped warnings (fine-grained #nowarn control), struct default parameters (to avoid heap allocations in optional args), tail-call improvements, and a preview of a parallel compiler that speeds up large F# solution builds. F# 10 also refines syntax (e.g. better property accessor syntax) to make the language more approachable. Both languages’ compilers come with new analyzers and warnings to help developers adopt these features safely. Importantly, there are no breaking changes in C# 14 or F# 10, so existing code should upgrade smoothly. [devblogs.m…rosoft.com], [devblogs.m…rosoft.com] [devblogs.m…rosoft.com] [infoq.com]

• Base Libraries & Security: .NET 10’s Base Class Libraries (BCL) were updated with new APIs and stronger security. One headline is expanded post-quantum cryptography support – .NET 10 adds implementations of emerging cryptographic algorithms designed to resist quantum attacks (specifically, Microsoft mentions ML-DSA and ML-KEM for signatures and key exchange). These are available via integration with Windows CNG and give .NET developers a head-start on future-proofing security. The networking stack introduces a new WebSocketStream API for cleaner, high-performance WebSocket usage. Also, TLS 1.3 is now fully supported on all platforms (including macOS), ensuring up-to-date security protocols. JSON serialization (System.Text.Json) is safer and faster – it now detects duplicate keys by default (preventing ambiguous JSON attacks) and provides more flexible configuration. Other improvements include additional LINQ methods, better reflection performance, and new diagnostic counters for runtime metrics. Notably, .NET 10 is the first release to ship with built-in support for .NET Aspire 13 – a cloud-native application framework that coordinates front-end and back-end services. Aspire (formerly an experimental project, now officially part of .NET) provides tooling for orchestrating microservices and multi-language workflows under a unified platform. In this release, Aspire 13 focuses on easier containerization, service discovery, and multi-language integration (e.g., coordinating Python or Node.js parts alongside .NET). It’s essentially an out-of-the-box solution for building cloud-native .NET applications, showing .NET’s evolution beyond just runtime into holistic app models. [infoq.com]

• Web and Client Workloads: All major frameworks aligned with .NET 10 have been updated:

  • ASP.NET Core 10: The web framework in .NET 10 brings both performance and feature enhancements. Kestrel, the web server, can now automatically trim its memory pool by evicting idle HTTP connections, which reduces memory usage under high load. ASP.NET Core also introduced built-in support for passkeys (FIDO2) in its Identity system, enabling passwordless authentication out-of-the-box with minimal code. Developers can now easily integrate biometric or device-based auth for web apps. The minimal APIs and gRPC services got improved ahead-of-time compilation support, meaning even faster startup and throughput when using NativeAOT. On the API side, .NET 10’s ASP.NET Core has OpenAPI 3.1 support and better endpoint metadata so that tools like Swashbuckle can generate more accurate Swagger docs. There’s also improved logging and diagnostics (including more detailed error pages for Blazor and richer telemetry for distributed tracing). Importantly, no breaking changes were introduced from ASP.NET Core 8/9 to 10 – so upgrading web apps should be straightforward, gaining benefits like ~10% better throughput observed in internal benchmarks (thanks to the runtime improvements). [visualstud…gazine.com] [infoq.com]
  • Blazor: Blazor in .NET 10 is more polished and production-ready. Blazor Server and WebAssembly got a new persistent component state feature, which allows preserving component state across prerendering or circuit reconnections (improving user experience for apps that prerender on the server then continue in the client). Blazor WebAssembly apps load faster due to linker and runtime packaging optimizations, and memory use is down. A big addition is the new QuickGrid component (an officially supported data grid for Blazor), which simplifies building interactive tables. Blazor’s forms and validation system now supports complex object graphs and provides better error feedback out-of-the-box. Lastly, Blazor’s JavaScript interop was enhanced: you can more easily call JS modules and even stream data between .NET and JS efficiently. While the community eagerly awaits the long-term “Blazor United” unification (still in development), Blazor in .NET 10 solidifies its position as a capable UI framework with improved performance and reliability. [infoq.com]
  • .NET MAUI 10: The cross-platform Mobile/Desktop UI framework reached a new level of maturity in .NET 10. On Android, .NET 10 MAUI supports the latest Android 16 (API level 34/UpsideDownCake) on day one – a result of direct collaboration with the Uno Platform team (who helped implement the Android 16 bindings). This means developers can target the newest Android features immediately with .NET 10. On iOS/Mac, MAUI updated to work seamlessly with Xcode 17 and macOS Sonoma. A notable new feature is XAML Hot Load with AI assistance: Visual Studio 2026’s XAML Live Preview in MAUI can now accept natural language tweaks (e.g., “make this button blue”), showcasing early AI integration even in client development. In terms of fundamentals, .NET 10 MAUI introduces global using directives for XAML (no more repeating namespace declarations across XAML files) and uses a XAML compiler source generator that checks bindings at compile time and produces optimized code (reducing startup times). MAUI’s control gallery expanded with Maps and MediaElement officially supported, and there are new APIs for window management on Windows (custom title bars, system tray integration). Overall, many developers who were cautious with MAUI in .NET 6/7 now see .NET 10’s MAUI as ready for prime time – it’s the first MAUI release on an LTS, with hundreds of bug fixes and performance improvements making it stable for production. [infoq.com] [visualstud…gazine.com]
  • Entity Framework Core 10: EF Core 10 was released alongside .NET 10 and requires the new runtime. This version of Microsoft’s ORM brings features that embrace modern data scenarios. A marquee addition is built-in support for Vector data types and similarity queries in SQL Server/Azure SQL. EF Core 10 can map a .NET Vector<float> or Span<byte> to the new VECTOR column type in SQL Server 2025, and it provides a LINQ extension for cosine similarity – enabling AI scenarios like semantic search directly in the database. Another big improvement: JSON columns are now first-class citizens. With SQL Server 2025 introducing a native JSON type, EF Core 10 can store and query JSON data without hacks (including indexing JSON fields). For Cosmos DB, EF added support for its new full-text search and improved translation of LINQ to Cosmos SQL. Developers also get quality-of-life enhancements: named query filters (enabling multiple global filters that can be turned on/off individually), better LINQ translation (e.g. more queries using GroupBy can execute server-side), and analyzers to catch raw SQL pitfalls at compile time. EF 10 focused on stability through its previews, so upgrading from EF 7 or 8 has minimal breaking changes. With EF Core 10 and .NET 10, organizations can build data-driven apps that leverage the latest database capabilities (including those tailored for AI and analytics) with confident long-term support. [infoq.com]

Despite the large scope of new features, .NET 10 was designed to be a smooth upgrade from .NET 8/9. The .NET team emphasized that barring a few deprecated APIs, most projects should upgrade with no code changes required. Early adopters (including parts of Bing and Microsoft Teams) ran .NET 10 release candidates in production and reported immediate wins – for instance, Bing saw improved 90th-percentile latencies simply by moving to .NET 10. As an LTS release, .NET 10 will be supported for three years (until Nov 2028), making it the ideal target for enterprises planning their platform standardization. Microsoft is strongly encouraging production apps to move to .NET 10 to benefit from the extended support and the plethora of enhancements. [devblogs.m…rosoft.com] [devblogs.m…rosoft.com]

Servicing Updates for .NET 8 and 9: In parallel with the fanfare for .NET 10, Microsoft issued its routine monthly patches for the currently supported versions. On Nov 11, the same day .NET 10 launched, .NET 8.0.22 (LTS) and .NET 9.0.11 (STS) were released. These November 2025 servicing updates contained only non-security fixes. (October’s updates had already addressed some critical security issues, such as a severe ASP.NET Core HTTP/2 vulnerability, so November’s did not have new CVEs.) The patches include minor reliability improvements in the runtime and ASP.NET Core, ensuring that .NET 8 and 9 remain stable. There were no feature additions or breaking changes – the focus is purely on maintenance. For example, a fix might address a rare JIT bug or a networking edge case; the details are in GitHub release notes. Microsoft also did not release any new .NET Framework updates in November (the last .NET Framework patch was in October for a WPF issue, and November had none). With .NET 8 still supported until mid-2026 and .NET 9’s support extended to 24 months (to Nov 2026), these servicing updates give organizations still on those versions confidence that their systems remain patched while they plan a move to .NET 10. It’s worth noting that .NET 6 (the LTS from 2021) is nearing end-of-life in early 2026; Microsoft is signaling that .NET 8 or 10 should be the next step for those applications to stay in support. [devblogs.m…rosoft.com] [manorrock.com], [manorrock.com] [devblogs.m…rosoft.com]

🛠 Tooling Updates (Visual Studio, CLI, Cloud)

November 2025 brought significant developer tooling releases to accompany .NET 10. Both Microsoft’s first-party tools and the broader ecosystem updated to ensure developers can fully leverage the new platform:

Visual Studio 2026 (v18.0): Microsoft’s flagship IDE had its official launch alongside .NET 10. Visual Studio 2026 was released on Nov 11, marking a major upgrade from VS2022. The theme of VS2026 is being an “AI-first, faster, more productive” IDE. Key improvements include:

• Deep GitHub Copilot Integration: VS2026 comes with Copilot “woven into the workflow” by default. This means AI assistance is available in all coding activities – IntelliSense suggestions are enhanced by AI, there’s an inline chat for asking coding questions, and Copilot can even generate entire files or refactor code on command. During debugging, an AI can explain exceptions or suggest fixes. This tight integration aims to boost developer productivity significantly, effectively making Copilot a built-in pair programmer.
• AI-Powered Features: Beyond Copilot, VS2026 introduces specific AI features. Profiler Agents continuously analyze your running application and highlight performance issues or memory leaks, often with suggested fixes (e.g., “This LINQ query causes heavy allocations, consider using XYZ” – and you can apply the fix with one click). Adaptive Paste is another novel feature: when you paste code into VS2026, the IDE, using AI context understanding, can automatically tweak the formatting, add missing using directives, or even convert the snippet to match your code style. Early testers found this especially useful when copying code from documentation or StackOverflow.
• New UI and UX: VS2026 sports an updated Fluent UI design, giving it a more modern look aligned with Windows 11. The interface is cleaner, icons are updated, and there’s a new “Light Blue” theme option. The general responsiveness of the UI is improved; Microsoft optimized solution load times and memory usage. For large solutions, the new *.slnx format is a boon – VS2026 can open these “solution cache” files much faster and handle mega-repositories more gracefully. (A .slnx can reference multiple .sln files and projects, helping to organize big codebases; VS2026 fully supports it, and backward-compatibility with VS2022 is maintained by also generating traditional solution files.) [visualstud…gazine.com], [visualstud…gazine.com]
• Better .NET 10 Support: Obviously, VS2026 fully supports all .NET 10 features – e.g., the code editor understands C# 14 syntax (with proper colorization and refactorings for things like extension properties), the designers support new MAUI controls, and the publishing tools can target .NET 10 runtime-dependent containers. Razor editing in Blazor projects is smoother (significantly fewer crashes when editing large .razor files, thanks to a revamped Razor Language Server). Hot Reload has less flicker and supports more types of edits at runtime, even on MAUI XAML. The debugging experience for .NET 10 got enhancements like parallel Stacks view improvements and better visualizers for Span<T> data.
• Upgrade and DevOps Integration: Visual Studio 2026 places a big emphasis on helping developers modernize and maintain apps. It embeds the .NET Upgrade Assistant tooling right into the IDE – if you open a .NET Framework project, VS will detect it and offer an “Upgrade to .NET 10” wizard (which internally runs the assistant plus Copilot for adjustments). There’s also integration with GitHub Actions: a new DevOps tab can scaffold CI/CD YAML for your solution, with .NET 10 build/test steps ready to go. For teams using Azure DevOps, VS2026 can create pipelines via a wizard as well. Essentially, Microsoft is recognizing that updating older projects and setting up cloud workflows are part of a modern dev cycle, and they’ve streamlined those tasks in the IDE.

It’s worth noting that Visual Studio 2022 (17.17) also received an update to support .NET 10 projects (for those not ready to jump IDE versions). However, many of the advanced features (especially the AI ones) are exclusive to VS2026. Microsoft calls VS2026 its “first intelligent IDE” – early reviews agree it’s a notable step forward in integrating AI with development. With VS2026’s GA, the era of yearly-named Visual Studios begins, and the product team has signaled more frequent improvements via the VS Insiders program, which will continue into the VS2026 cycle.

.NET CLI and SDK: The .NET 10 SDK (v10.0.100) shipped with some handy enhancements:

• The dotnet CLI got quality-of-life improvements. For example, you can now run dotnet publish -p:PublishProfile=FolderProfile to easily use publishing profiles, and dotnet test has better output for skipped tests (no more confusion whether tests ran or not). A notable addition is an experimental global tool runner called dnx (reviving an old moniker) – developers can try dotnet dnx toolname to run local tools with less boilerplate. This was in preview and remains off by default, but it hints at simplifying how CLI tools execute.
• A big new feature is the introduction of the SLNX solution format. The SDK’s templates now optionally generate a .slnx which references the traditional .sln. This format works with VS2026 to manage large solutions more effectively. It’s helpful for monorepos where you might want to treat subsets of projects as separate “workloads.” [visualstud…gazine.com]
• The SDK also improved its built-in container support. .NET 10 enables specifying container image architectures and base images more flexibly. For instance, you can choose Alpine vs Debian in a single property, and the dotnet publish --os linux --arch x64 -p:PublishProfile=DefaultContainer will produce an OCI image with manifest lists for multi-arch. This built-in containerization (which started in .NET 8) is now robust enough that many projects can ditch external Dockerfiles for simple scenarios.
• Additionally, the .NET CLI can now output JSON for certain commands (like dotnet list package --out json), making it easier to script around in CI environments. NuGet package auditing was also added: dotnet list package --vulnerable uses data from GitHub’s advisory database to flag known vulnerable packages (an integration that helps improve supply chain security).
• On cross-platform dev, the C# Dev Kit for VS Code reached version 1.0 around .NET Conf. This extension brings an IDE-like experience to VS Code for C#, and in November it added full support for .NET 10 and C# 14 (including IntelliSense for new syntax). Many .NET devs who prefer VS Code now have a first-class option maintained by Microsoft. Similarly, JetBrains Rider 2025.3 (released in December, with EAP in Nov) included .NET 10 support and continued performance improvements (reducing overhead of background inspections on big solutions).

Overall, the .NET 10 launch was accompanied by a well-prepared toolchain: whether you write code in Visual Studio, VS Code, or Rider, and whether you deploy to Windows, Linux, or containers, the tools are updated to handle .NET 10 smoothly.

Azure and Cloud Tooling: Cloud platform support for .NET 10 was essentially instant:

• Azure: On day one, Azure App Service and Azure Functions announced support for .NET 10 – you could deploy .NET 10 web apps and functions in Azure from the GA date. The Azure SDK libraries (which ship monthly) were also aligned. In late November, the Azure SDK team released updates so that all major client libraries (Azure Storage, Cosmos DB, KeyVault, etc.) officially target .NET 10 and take advantage of its improvements (e.g., using new System.Net.Http features). The Azure SDK blog highlighted improvements in Azure Cognitive Search: a new .NET SDK version supports vector search capabilities for AI applications. And Azure AI Foundry (a service to orchestrate AI models and agents on Azure) had its .NET SDK reach 1.0, making it easy to deploy AI “agent” backends in the cloud using the same concepts as the on-prem Agent Framework. [manorrock.com], [infoq.com]
• GitHub: GitHub Actions updated their virtual build environments by mid-November – the actions/runner images for Windows, Ubuntu, and Mac all had .NET 10 SDK installed. This means CI pipelines could start building and testing .NET 10 apps without extra configuration. This was important for library authors shipping .NET 10 builds; many NuGet package maintainers took advantage of it to publish .NET 10–compatible versions right away.
• AWS: Amazon Web Services also embraced .NET 10 quickly. The AWS Toolkit for Visual Studio (an extension to deploy to AWS services) was updated to work with VS2026 and .NET 10 projects by the end of November. Even more interestingly, at AWS re:Invent (late Nov/early Dec), AWS announced expanded capabilities in AWS Transform for .NET – their automated modernization service. The new version (GA Dec 1) can convert legacy ASP.NET Web Forms UI into Blazor components on ASP.NET Core, and also migrate on-prem SQL Server databases to PostgreSQL (Aurora) within the same workflow. Essentially, AWS is providing .NET customers a path to full-stack modernization: upgrade .NET Framework code to .NET Core/10, translate old web UI to modern Blazor, and move the DB to cloud, in one automated project. This underscores that .NET modernization is a priority not just for Microsoft but across the industry (more on modernization in the next section). AWS’s support also means .NET 10 is well-supported on AWS for those deploying in that ecosystem (e.g., AWS Lambda now has a .NET 10 runtime container ready). [awsinsider.net], [awsinsider.net]
• Other Tools: In the DevOps arena, Docker published official .NET 10 SDK and runtime images on Docker Hub immediately, and Kubernetes Helm charts for .NET were updated to default to .NET 10 for new deployments. Postman updated its code generators and Collections to account for minimal APIs in .NET 10 (ensuring the generated C# code uses the new style). Also notable, OpenTelemetry .NET (the standard for tracing/metrics) released version 1.5 in November, adding instrumentation for some .NET 10 specifics and ensuring that telemetry from .NET 10 apps can be collected without issues. This includes tagging of AI spans – e.g., if you use the new Microsoft.Extensions.AI pipelines, OpenTelemetry will correctly label those operations. All these show a mature ecosystem response: by the time .NET 10 launched, the surrounding tools and services were ready, making the upgrade and adoption experience very smooth for developers.

🏗️ Modernization & Migration

With .NET 10 out as a new LTS, modernizing older .NET applications was a major focus in November. Microsoft and the community have been driving the message that now is the time to bring legacy .NET apps up to date, and new AI-powered tools are making that easier than ever.

GitHub Copilot for Modernization (GA): One of the biggest announcements at .NET Conf 2025 was the general availability of GitHub Copilot’s App Modernization feature. This tool, integrated into Visual Studio, acts as an AI assistant specifically trained to help upgrade legacy projects. For example, if you open a .NET Framework 4.6 MVC project in VS2026 and invoke the modernization agent (@modernize in the Copilot chat), it will analyze your project and produce a checklist: update target framework, convert packages, replace obsolete APIs, etc. It then walks you through each step conversationally. Developers have reported that Copilot can handle a surprising amount of the heavy lifting: it will rewrite Web.config into appsettings.json, suggest replacements for old libraries (e.g., replacing Log4Net with Serilog), and even convert certain code patterns (like old HttpHandlers into ASP.NET Core middleware). In one case study shared at .NET Conf, FMG Insurance demonstrated how they used Copilot’s modernization on several internal apps and were able to get them running on .NET 10 “in hours instead of weeks.” They combined it with automated testing to validate nothing broke. The story included an example where an old WCF service call was converted to a gRPC client with Copilot’s help. Copilot doesn’t magically do everything, but it gets you, say, 80% of the way, significantly lowering the cost and risk of upgrading legacy code. [devblogs.m…rosoft.com]

.NET Upgrade Assistant and Analyzer Updates: Alongside Copilot, the open-source .NET Upgrade Assistant remains a foundational tool. There wasn’t a new version released in November (the last big update was earlier in 2025), but it’s fully capable of migrating projects to .NET 10. The typical recommended workflow now is: run Upgrade Assistant to handle the project file and basic conversion, then use Copilot to fix up the code. Microsoft updated their documentation and even provided a Learn module in November on using “Upgrade Assistant + Copilot” together. Additionally, Roslyn analyzers that warn about outdated APIs were updated for .NET 10 – for example, an analyzer will flag System.Web references once you target .NET Core, reminding you to use the new equivalents. Visual Studio 2026’s built-in “Upgrade” dashboard surfaces these analyzer suggestions in one place. The tooling ecosystem for upgrades has matured to the point that most of the rote work can be automated, leaving developers to focus on testing and UI/UX adjustments. [devblogs.m…rosoft.com], [devblogs.m…rosoft.com]

Real-world Success & Guidance: The community has been actively sharing success stories and guides on modernization:

• Microsoft’s keynote highlighted that internally, many products are moving to .NET (for instance, Office add-ins are planning to move off .NET Framework). The .NET team extended support for .NET 9 to 24 months largely to give companies more breathing room to plan upgrades, but they still underscore that moving to .NET 10 LTS is ideal. [devblogs.m…rosoft.com]
• A popular blog in November by Ben Abt titled “.NET 10 LTS Upgrade Playbook” laid out the case for upgrading and suggested focusing on performance wins to justify the effort (he cites an internal user on HackerNews who said they “get a 10-20% CPU decrease every time [they] upgrade to the next .NET”). That kind of recurrent efficiency gain resonates with leadership when deciding on upgrades. [theregister.com], [theregister.com]
• Another article on LinkedIn by an MVP provided a checklist for breaking a monolith during modernization: recommending that if you’re going to touch all that code anyway, consider refactoring into separate services or at least decoupled modules as part of the upgrade. However, this can complicate the process, so others suggest doing a straight tech upgrade first, then structural changes after.
• The Azure DevOps team released a migration guide (overlooked previously) for moving on-prem TFS build pipelines that use old MSBuild tasks onto GitHub Actions with .NET 10 – not a common scenario for everyone, but it shows that even the devops processes around .NET are being modernized (retiring older build servers in favor of cloud CI with modern .NET tooling).

AWS’s Modernization Push: It’s not just Microsoft urging upgrades. As mentioned in the tooling section, AWS introduced an expanded .NET modernization service. In AWS’s own words, customers wanted to handle “the common three-tier Windows pattern” in one go. With the new AWS Transform Full-Stack Modernization, an enterprise can point the tool at an old ASP.NET app with a SQL Server database, and the tool will migrate the database schema to PostgreSQL (on AWS Aurora), update all the EF calls in code, and simultaneously convert any Web Forms UI to Blazor on .NET Core. This is quite groundbreaking – Web Forms to Blazor conversion automates one of the trickiest parts of legacy .NET modernization (those UIs are decades old and very different). The AWS tool likely can’t handle 100% of cases (complex Web Forms may need manual fixes), but it provides a huge head-start. It also underscores that cloud providers see value in facilitating .NET upgrades: modernizing apps often means cloud migration, so they’re investing in tools to make it as easy as possible. For .NET developers, it means there are multiple robust options (Microsoft’s tools, AWS’s tool, third-party services) to help with modernization. [awsinsider.net] [awsinsider.net], [awsinsider.net]

“Don’t Wait” Mentality: Across blogs, webinars, and conference talks in November, the resounding advice is not to procrastinate on .NET upgrades. .NET 6 will be out of support by spring 2026, and .NET Framework 4.8 (while technically supported as part of Windows) gets no new improvements. The availability of an LTS like .NET 10 with three years of support provides a stable target. One executive from a fintech company was quoted in a panel: “Running on .NET Framework is a business risk now – talent wants modern tech, and security updates are limited. .NET 10 is our escape hatch to future-proof our software.” This sentiment is increasingly common. In many organizations, upgrade projects that had been perpetually deferred are now being green-lit, thanks in part to the existence of tools like Copilot that make the effort seem less daunting. Microsoft is doing its part to lower barriers: for instance, Azure App Service’s migration assistant (which helps move on-prem web apps to Azure) now directly suggests running the .NET Upgrade Assistant if it detects a .NET Framework app, effectively integrating modernization into the cloud move workflow. [devblogs.m…rosoft.com]

In summary, November 2025 accelerated the .NET modernization wave. With .NET 10’s release, it’s clear that the future of .NET is here, and the path from older versions has never been smoother. If you have apps on .NET Framework 4.x, .NET Core 3.1, or even .NET 5/6, there’s strong consensus that now is the time to upgrade. The combination of tooling, guidance, and compelling benefits (performance, support, cloud readiness) makes the case undeniable. As one .NET Conf speaker quipped: “The train is leaving the station – and it has an AI conductor now – so hop on!”

🌐 Ecosystem & Community Highlights

Beyond Microsoft’s official releases, the .NET ecosystem was buzzing in November 2025 with open-source updates, community content, and events. Here are some highlights:

Open-Source Frameworks & Libraries:

• Uno Platform 6.4 & Uno Platform Studio 2.0: We discussed this in the summary table, but it’s worth emphasizing how significant this is for the .NET ecosystem. Uno Platform (an OSS framework enabling truly cross-platform UI from a single codebase) shipped version 6.4 on the same day as .NET 10, ensuring that developers using Uno can immediately move to .NET 10. Uno 6.4’s collaboration with Microsoft helped .NET MAUI support Android 16 from day one – a great example of open source contributing directly to .NET’s core. Additionally, Uno’s team jumped on the AI trend: Uno Platform Studio 2.0 (their paid tooling) introduced an AI Hot Design Agent that lives in Visual Studio’s design view. This agent can analyze your XAML visual tree and, via a natural language prompt, rearrange or restyle your UI. For example, a developer can ask, “Convert this page’s layout to a 3-column grid,” and the agent will adjust the XAML accordingly. Under the hood, Uno Studio uses two MCP servers (one exposing design-time info, one exposing runtime app state) to allow an AI agent to query and manipulate a live running app. It’s quite futuristic – essentially AI-driven WYSIWYG design – and it showcases how AI can assist in app development beyond code editing. Uno also added support for the new .slnx format and performance improvements (like moving some Skia rendering tasks off the UI thread for smoother graphics). For Windows developers, Uno 6.4 introduced neat tricks like custom title-bar buttons and extended client areas. The synergy between Uno and MAUI means .NET developers have multiple robust options for cross-platform development, both stepping up with .NET 10 support and new features. [infoq.com] [infoq.com], [infoq.com]
• ASP.NET Core Ecosystem: Within the ASP.NET Core space, there were incremental but important library updates. YARP (Yet Another Reverse Proxy) released v2.1, compatible with .NET 10, which included improved HTTP/2 and WebSockets handling. Serilog, a popular logging library, posted an update mainly to target .NET 10 and incorporate some performance improvements that take advantage of new BCL APIs (like a faster string interpolation handler in .NET 10). FluentValidation likewise put out a minor release to support record types better in C# 14 scenarios (no breaking changes, just keeping up with the language). On the bleeding edge, an experimental project from the community brought gRPC-Web support directly into ASP.NET Core (so that a browser can call gRPC services without a proxy). Google’s team is involved, and there’s now a preview package for ASP.NET Core 10 that you can plug in to accept gRPC-Web calls natively. This could simplify architectures where Blazor WebAssembly or other JS front-ends talk to .NET backends via gRPC.
• Data & ML Libraries: The Entity Framework Core 10 release (being part of .NET 10) was big for data. Outside of EF, other data providers kept pace: the Npgsql PostgreSQL provider released v7.0 to fully support EF Core 10 and the latest PostgreSQL features. It also improved batching performance for writing large datasets. Dapper, the lightweight ORM, didn’t need an update for .NET 10 (works as is), but its maintainers ensured it passes all tests on .NET 10 and noted a ~5% performance increase due to the runtime improvements. In the machine learning space, ML.NET 2.1 was released – a modest update adding some new trainers and enhancing integration with TorchSharp (which allows leveraging PyTorch models in .NET). ML.NET 2.1 also now targets .NET 10 for its nuget packages, though it remains fully back-compatible to .NET 6. Meanwhile, TorchSharp itself (the .NET bindings for Torch) released a version aligning with PyTorch 2.1, giving .NET 10 developers access to the latest in deep learning. One of the community-driven ML projects, LLamaSharp, gained further attention: in November, contributors added support for Llama 3 models and optimized GPU memory usage by 30%, making it feasible to run a 13B parameter model on a high-end consumer GPU in .NET. LLamaSharp now has ~3.5k stars on GitHub, reflecting the interest in running LLMs locally on .NET. Combined with the Agent Framework, it’s possible to imagine fully offline multi-agent .NET applications using local AI models. [infoq.com]
• Community Tooling: The .NET Community Toolkit (which includes the MVVM Toolkit and other helpers) released an update to coincide with .NET 10. The MVVM Toolkit 8.2 adds source generators that take advantage of C# 14’s new Roslyn features for even faster compile-time property generation. The MAUI Community Toolkit also pushed a .NET 10 update, adding a few new controls like Popup improvements and compatibility with iOS17/Android16. These community-driven toolkits are essential for many apps, so having them ready for .NET 10 is part of the smooth upgrade story.
• Polly v8 Beta: Polly, the resilience library (policies for retry, circuit-breaker, etc.), announced a Beta of Polly v8 in November. This new version embraces modern .NET features – it will support async streams (so you could have, e.g., a retry policy that re-subscribes to an IAsyncEnumerable sequence on failure). It also refactors the policy registry to use generic host and IOptions, aligning it with typical ASP.NET Core patterns. The maintainers said v8 final is expected in early 2026, but early drafts show nice integration with IServiceCollection and a simpler API for defining policies. Many devs still use Polly v7 (which works fine in .NET 10), but v8 will be a welcome refresh after several years.
• NuGet Ecosystem Security: By November, the initiative of NuGet package signing and trusted publishing has taken hold widely. We saw maintainers of top libraries like AutoMapper, FluentAssertions, and MassTransit announce that they’ve adopted the new GitHub OIDC workflow for NuGet (so no more long-lived API keys that could leak). The .NET Foundation and NuGet.org have been pushing this to enhance supply chain security. Also, NuGet.org started showing a “Sponsorship” section for projects that have it configured. Many OSS authors added a GitHub Sponsors or OpenCollective link to their package metadata in November, so that when developers browse NuGet, they are reminded that these free libraries have maintainers who might appreciate support. It’s a small change, but it could help sustain the open-source contributors in the .NET ecosystem. [manorrock.com]

Conferences & Events:
November had the year’s biggest .NET event and more:

• .NET Conf 2025 (Nov 11–13): This three-day online conference was the centerpiece of November. Co-hosted by Microsoft and the .NET community, it attracted over 100,000 viewers during the live sessions (and many more via on-demand). Day 1 was jam-packed with product launches (the .NET 10 and VS2026 keynote, plus deep dives into C# 14, ASP.NET Core, MAUI, etc.), Day 2 focused on Azure and cloud-native scenarios, and Day 3 was community-driven talks from around the world. A few notable moments: [devblogs.m…rosoft.com]
  • The opening keynote (Scott Hanselman & team) highlighted .NET’s momentum: over 7 million developers use .NET/VS monthly and more than 23,000 PRs were contributed to .NET 10’s development – a testament to open source engagement. They reiterated the vision of .NET as “a complete development platform that developers love, and businesses trust.” That framing was illustrated by examples of .NET inside Microsoft (Bing, Xbox, Copilot) and outside (industry users like H\&R Block, Chipotle, etc.). [devblogs.m…rosoft.com] [devblogs.m…rosoft.com]
  • Many exciting demos: One showed Visual Studio 2026 using Copilot to upgrade a legacy app live on stage – the audience saw an old ASP.NET MVC app get transformed into an ASP.NET Core app in minutes with AI help. Another demo combined multiple Agent Framework agents to schedule meetings: one agent pulled free/busy data from Outlook, another composed email text – it was a futuristic showcase of how devs might build apps differently using these AI primitives.
  • .NET Conf also celebrated 10 years of .NET open source (since the first open-sourcing in 2014) and the 10th anniversary of .NET Conf itself. There was a fun montage of how far .NET has come since 2015 – from the early .NET Core days (project.json and DNX, anyone?) to now.
  • On Day 3, community speakers from over a dozen countries presented. Topics ranged from “Building a Real-Time Game with Unity and .NET 10” to “F# for Quantitative Finance”. This global involvement underscored .NET’s broad reach. Microsoft even did a special China simulcast with Chinese subtitles and local hosts, acknowledging the large developer base there. [devblogs.m…rosoft.com]
• Update Conference Prague 2025 (Nov 13–14): Right after .NET Conf, one of Europe’s biggest in-person .NET events took place in Prague. It featured 40+ sessions across topics like .NET 10, cloud, security, and Blazor. Many international speakers (including several Microsoft MVPs and Regional Directors) delivered talks. Given the timing, .NET 10 content was hot: there were sessions such as “Deep Dive into C# 14” and “Optimizing ASP.NET Core 10 in Kubernetes.” The conference was sold out, showing that in-person .NET community events are thriving again. Attendees got to hear from experts like Julie Lerman (on EF Core 10) and Filip W. (on source generators in C#) in an intimate setting compared to the global .NET Conf. It also provided a chance for European devs to network and celebrate the new release together.
• Local Meetups: All through November, local .NET user groups held meetups themed around .NET 10. For instance, the Sydney .NET User Group had a “.NET 10 Launch Party” with a presentation by a Microsoft Cloud Advocate, and the .NET São Paulo community did a hybrid meetup to discuss top features of .NET 10 in Portuguese. These grassroots events help foster local excitement and answer practical questions about upgrading. Many organizers reported that turnout was higher than usual – presumably because developers were eager to learn about the new tech (or just happy to gather in person post-pandemic). Many meetups also featured demos of the new AI tools – one group did a live demo of Copilot generating tests, which blew the minds of some attendees who hadn’t seen it in action yet.
• GitHub Universe 2025 (Nov 8–9) in San Francisco (and streamed) also had relevant content. While Universe is not .NET-specific, this year a significant portion was about AI in developer tools – with GitHub showcasing the Copilot enhancements (like test generation and the modernization tooling that were then launched at .NET Conf). Microsoft’s Developer Division leaders participated in Universe, bridging the GitHub and .NET stories. Universe confirmed that AI-assisted development is a major industry trend, not just for .NET but across all ecosystems. [devblogs.m…rosoft.com], [devblogs.m…rosoft.com]
• Lastly, November had the usual array of smaller conferences and the lead-up to Microsoft’s Ignite 2025 (which was in early December). At Ignite (though technically December), Satya Nadella mentioned .NET 10 in context of cloud workloads, reinforcing that it’s a strategic platform for the company.

Community Content (Blogs, Videos, Podcasts):
The .NET community was extremely active in producing content to help everyone digest the new releases:

• Blogs: Many bloggers published “What’s new in .NET 10” summaries or deep-dives. For instance, Andrew Lock wrapped up his long-running preview series with a post on UnsafeAccessorAttribute in .NET 10 and how it boosts libraries like JSON serialization. Alvin Ashcraft’s Morning Dew and The Morning Brew aggregated dozens of .NET 10 articles each week. A standout blog was by Volosoft (“.NET 10: What You Need to Know”), which interestingly was targeted at CTOs, highlighting the business case (LTS, support until 2028, performance for cost savings, etc.). On the security front, a blog by William D.* dissected the October HTTP/2 vulnerability and praised how quickly it was fixed in .NET 8/9 – reminding folks to stay current with patches.
• Video Content: The official .NET YouTube channel uploaded all .NET Conf sessions, which immediately became a trove of learning material. Community YouTubers were prolific too. Nick Chapsas released several videos in November: “What’s new in C# 14 & .NET 10” (a 20-minute tour of his favorite features), a short titled “.NET Will Get MUCH Faster” highlighting performance anecdotes, and a fun one “I tried the new AI agent framework in .NET 10” where he builds a small maze solver with two agents. Tim Corey streamed Q\&As about whether one should upgrade to .NET 10 or wait (his advice: if on LTS, go to .NET 10 soon; if on 9 STS, maybe test 10 and jump straight since 9 support will end next year). Microsoft’s Channel 9 hosted an episode of On .NET Live focusing on F# 10, where Phillip Carter chatted with community F# leads about the significance of parallel compiler and what might come in F# 11.
• Podcasts: DotNetRocks! did an episode with members of the .NET team, reflecting on the journey to .NET 10. They discussed how feedback from .NET 8/9 shaped some of the .NET 10 improvements (for example, the demand for more built-in AOT support and the inclusion of SQLite in the ASP.NET dev cert by default to ease onboarding new devs). Merge Conflict (a podcast by James Montemagno and Frank Krueger) had an enthusiastic review of .NET 10 from a mobile developer’s perspective – they loved seeing MAUI on LTS and debated if Xamarin.Forms apps should finally be migrated now (consensus: yes, MAUI on .NET 10 is stable enough to justify it). Another interesting bit: Hanselminutes featured an interview with an engineer at a bank who led a .NET Framework to .NET 8 upgrade; it was a timely discussion about challenges in regulated industries upgrading mission-critical apps, and how they tackled it step by step.
• Newsletters: Weekly newsletters like C# Digest, .NET Ketchup, and Sergey Tihon’s F# Weekly provided great roundups. For example, .NET Ketchup Week 48 listed out links to Nick’s videos, the official blogs, and even some tweets that went viral (like one where a dev showed a 50% reduction in AWS bill after upgrading to .NET 10 due to reduced CPU – anecdotal, but gripping). F# Weekly in late November was largely about #FsAdvent 2025 – an annual F# community event in December where each day a different person writes an F# blog post. Sign-ups happened in November and filled up quickly, showing the F# community’s passion. Topics teased included “High-performance F# with Span” and “WebAssembly via F# and Bolero”.
• GitHub Activity: On GitHub, the dotnet/runtime repo saw an influx of new issues as people started testing .NET 10 in real scenarios. By end of November, .NET 10.0.1 (the first patch, mostly minor fixes) was already being prepared – some community-found issues like a rare ARM64 JIT assert and a regression in AssemblyLoadContext unloading were fixed and queued for that patch. Meanwhile, various OSS projects merged pull requests to support .NET 10. For instance, the MassTransit project (a distributed application framework) merged updates to utilize the new PriorityQueue<T> from .NET 10’s BCL where appropriate, simplifying their code. DNN (DotNetNuke), a .NET Framework-era CMS that’s being modernized, had community contributors start a fork to port it to .NET 8/10, inspired by the new tools.

Overall, the .NET community in November 2025 was vibrant, enthusiastic, and highly engaged. The launch of .NET 10 galvanized content creators, open-source maintainers, and everyday developers alike. There was a palpable excitement in the air – not only about the shiny new features and performance gains, but also about how AI is changing the development landscape and how .NET is at the forefront of that shift. One developer tweeted, “Been doing .NET since 2005, and this is the most excited I’ve been about a new release. .NET 10 feels like the future is here.” That sentiment seems widespread.

🤖 .NET + AI: New Frontiers in Intelligent Apps

Throughout 2025, AI has been a dominant theme in tech, and November’s .NET releases firmly embedded AI capabilities into the .NET ecosystem. Both the product features and the messaging indicate that Microsoft envisions .NET as a premier platform for AI-powered applications and for AI-assisted development. Here we’ll explore the major AI-related developments:

Microsoft Agent Framework (Preview): One of the headline innovations unveiled at .NET Conf was the Microsoft Agent Framework for .NET. This is a new high-level framework (currently in preview on NuGet) that allows .NET developers to create applications composed of multiple cooperating AI “agents”. An agent here is essentially an AI-powered component that can perform tasks, possibly using large language models or other AI models, and interact with users or other agents. The Agent Framework builds on concepts from Microsoft’s Semantic Kernel and the experimental Autogen library, unifying them into an official SDK. With it, developers can: [devblogs.m…rosoft.com], [visualstud…gazine.com]

• Define multiple agents with different roles/goals (e.g., an “Email Answerer” agent and a “Scheduler” agent).
• Coordinate conversations and tasks between these agents. The framework supports sequential workflows (one agent after another) as well as parallel or even conversational interactions between agents. For example, agents can “debate” or collaborate to come up with a solution, all orchestrated by the framework. [visualstud…gazine.com]
• Manage state and context easily. The framework introduces a concept of a “context object” that agents can read from and write to. This way, if one agent gathers info (say, fetches data from a database), another agent can use it.
• Crucially, the Agent Framework integrates with .NET’s dependency injection and logging patterns, so agents can use regular services (like database contexts or HTTP clients) as “tools.”

One exciting aspect is the introduction of AG-UI (Agentic UI) – a lightweight protocol for building user interfaces that can interact with these agents in real-time. AG-UI is essentially a set of guidelines (and a provided ASP.NET Core middleware) for streaming interactions: think of it like how SignalR works, but specifically for AI agent conversations. It allows multiple agents to send messages to a UI (and possibly to each other) and for the UI to show typing indicators, partial responses, etc. Microsoft released a package Microsoft.Agents.AI.Hosting.AGUI.AspNetCore that makes it easy to host an AG-UI endpoint in a web app. On the client side, developers can either use provided web components or build their own interface (e.g., a chat window in Blazor or MAUI) that adheres to the protocol. The result is that you can build experiences similar to ChatGPT with plugins, entirely in .NET: multiple bots discussing or working together, with the conversation appearing live to the user. This framework was demonstrated in a .NET Conf session where two agents (one with knowledge of a product catalog and another with knowledge of user reviews) collaborated to answer a complex question in a single chat UI. [visualstud…gazine.com], [visualstud…gazine.com]

Model Context Protocol (MCP) and Tool Integration: Along with the Agent Framework, Microsoft announced the Model Context Protocol (MCP) C# SDK in preview. MCP is an open protocol (co-developed by Microsoft, as well as used in GitHub Copilot internally) that defines how AI models/agents can safely access external tools and data. The idea is to avoid giving an AI model direct free rein over your system, and instead expose specific actions through a controlled interface (the protocol). The MCP C# SDK allows you to both implement new tools that agents can call and to connect agents to existing tools over this protocol. For example, you could create an MCP server that exposes “QueryDatabase” and “SendEmail” functions from your application – an agent can then invoke those via the protocol, with all the proper security and serialization handled by the SDK. Microsoft revealed that their products like Xbox Gaming Copilot and Copilot Studio (an internal tool for pair programming) already use MCP with .NET – in fact, Copilot Studio is a Blazor WebAssembly app with C# agents that leverage MCP to talk to Azure DevOps and other services. By releasing the SDK, Microsoft is encouraging developers to create a whole ecosystem of extensible AI plugins for .NET apps. The preview includes new project templates (a “MCP Server” template, which is essentially a minimal ASP.NET Core API with some scaffolding to define actions). One can imagine, for instance, companies building internal MCP servers to let AI agents fetch inventory data or perform transactions in a controlled way, or community-built MCP servers to interface with popular services (like a GitHub MCP server that an agent could use to file issues or read repos). [devblogs.m…rosoft.com]

Microsoft.Extensions.AI: To support AI development patterns, .NET 10 introduced the Microsoft.Extensions.AI library (which had been in experimental preview and reached a stable phase). This library provides standardized interfaces for AI services in .NET. For example, it defines an IChatClient interface. Instead of directly calling OpenAI’s REST API or Azure OpenAI’s SDK, you can code against IChatClient and swap implementations. Microsoft provides implementations for OpenAI, Azure OpenAI, and even local runtimes like Ollama (for running models on-device). It also includes abstractions for text embedding generators, image generators, etc. The idea is similar to how ILogger works for logging – you write to the abstraction, and plug in any provider. Additionally, Extensions.AI adds familiar ASP.NET Core patterns to AI calls: you can pipeline middleware for AI requests (e.g., logging prompts, handling rate limiting) and use dependency injection to provide AI clients. It’s a subtle piece, but this library is the glue that connects traditional .NET programming with AI services in a clean way. The Agent Framework uses it under the hood, and ASP.NET Core’s AI endpoints register these services by default. This means .NET developers can incorporate AI features (like generating a summary or classification) without tying their code to one provider – making their apps more future-proof as the AI landscape evolves. [visualstud…gazine.com]

Copilot Enhancements in Dev Workflow: We’ve touched on this in modernization, but there’s also GitHub Copilot for Testing. Announced in preview, this feature leverages AI to analyze your C# code and generate unit test methods automatically. It can scaffold tests using frameworks like xUnit or MSTest based on your preference. More impressively, if you run tests and one fails, Copilot can attempt to diagnose the failure and suggest a code change to fix the bug. This essentially closes the loop for developers: AI can now write the test and then help fix the code until the test passes. It’s still early (the suggestions can sometimes be off-mark), but many see this as a revolutionary aid for improving code quality. A .NET Conf demo showed Copilot generating a suite of regression tests for an old class that lacked any – a task that would have taken a human hours, done in minutes. This could greatly aid projects in catching up on technical debt. [devblogs.m…rosoft.com]

AI in Other Aspects of .NET:

• ML.NET and Azure AI Integration: Microsoft continues to bridge its traditional ML tooling with the new AI wave. Azure’s AI services (like Azure OpenAI, Cognitive Services) have robust .NET SDKs, which were showcased in Day 2 of .NET Conf. For instance, combining Azure Cognitive Search (now with vector search) and Azure OpenAI to create domain-specific chatbots was demonstrated using pure .NET 10 code. Meanwhile, ML.NET is positioning itself to work in tandem with these – for example, ML.NET can be used to create embeddings or perform classification that supplements what large language models do.
• Semantic Kernel v1.0: Semantic Kernel, the open-source SDK for building AI “skills” in .NET, reached a v1.0 Release Candidate by November. SK was a precursor to the Agent Framework; it allows you to define semantic functions (prompts with placeholders) and orchestrate them with traditional code. With the Agent Framework taking the spotlight, Semantic Kernel will likely serve as the foundation and remain useful for simpler scenarios. SK added better support for chaining prompts and caching results (to save on API calls) in its RC.
• AI in APM/Monitoring: Interestingly, Microsoft is incorporating AI telemetry in monitoring tools. For example, Application Insights can now recognize “AI requests” and display them as a distinct dependency type (so calls to an LLM API show up differently from HTTP calls). And an Azure preview was mentioned where App Insights can even do anomaly detection on those LLM calls (like if the content of responses changes drastically). This is more on the DevOps side, but relevant for teams building AI features into .NET apps.

The bottom line is that .NET 10 doesn’t just improve the fundamentals of building software – it expands what you can build by integrating AI as both a first-class runtime component and a development assistant. A year ago, many .NET developers were just experimenting with calling AI APIs. Now, with .NET 10 and VS2026, they have out-of-the-box tools to build AI-rich applications (multi-agent systems, AI-assisted user experiences) and to leverage AI in the development process (Copilot, AI analyzers). It’s a synergistic approach: not only “AI for .NET” (making .NET apps smarter) but also “.NET for AI” (giving AI solutions the robust, scalable platform of .NET to run on).

As we wrap up the November 2025 Pulse, it’s clear that the .NET platform is at an inflection point. The release of .NET 10 with its LTS stability, performance leaps, and built-in AI support sets the stage for the next generation of apps. The community’s rapid adoption and the rich ecosystem of libraries and tools mean developers have everything they need to succeed. Whether it’s modernizing a mission-critical enterprise app or crafting a cutting-edge AI-powered solution, .NET in late 2025 provides a comprehensive, future-ready platform. The excitement and optimism in the community are well-founded – with .NET 10, many are saying this is the .NET we’ve been waiting for, blending the best of maturity and innovation. Happy coding on .NET 10!

[devblogs.m…rosoft.com], [visualstud…gazine.com]