Your AI-generated monthly roundup of .NET framework and platform updates. Please direct your comments directly to us at blog@manorrock.com
Welcome to the October 2025 edition of Pulse on .NET, where we track the latest releases, announcements, and trends across the .NET ecosystem. This month marked the final preparations for .NET 10âs launch, with the last release candidate shipping and .NET 8/9 receiving critical security updates. We also saw continued improvements in developer tooling (Visual Studio 2026 previews and Azure SDK updates), community-driven contributions (like Uno Platform teaming up with Microsoft on cross-platform features), and a growing emphasis on AI integrations in .NET. In this post, weâll cover .NET runtime & SDK releases, updates to key frameworks (ASP.NET Core, EF Core, MAUI, Blazor), tooling news (Visual Studio, GitHub Copilot, Azure SDKs), community highlights (open-source projects, content, and events), and a new section on .NET + AI (ML/AI libraries and tools shaping the developer experience).
To start, hereâs a quick summary of October 2025âs key .NET updates and their release dates:
| Update | Release Date | Highlights | Source |
|---|---|---|---|
| .NET 10 RC2 (Release Candidate 2) | October 14, 2025 | Final .NET 10 preview (go-live license) before November GA; no new features â focused on quality/stability; includes .NET MAUI refinements (Android API 36.1, XAML source gen, etc.) [infoq.com], [infoq.com]. | .NET Blog (RC2 announcement) [visualstudâŚgazine.com] |
| .NET 8.0.21 & 9.0.10 (Servicing) | October 14, 2025 | Patch Tuesday updates for .NET 8 LTS and .NET 9 STS with security fixes (addressing several CVEs) [devblogs.mâŚrosoft.com] and reliability improvements; no new features. .NET Framework 4.8.1 also received a security patch (RCE vuln) [devblogs.mâŚrosoft.com]. | .NET Blog (T. Overfield) [devblogs.mâŚrosoft.com] |
| Visual Studio 2026 Insiders Update (Preview) | Early-Mid Oct 2025 | Continued preview of VS 2026 with deep AI integration and full .NET 10 RC support. Visual Studio 2026 Insiders (v18.0 Preview) supports .NET 10 RC2 development out-of-the-box [visualstudâŚgazine.com]. Performance tweaks and bug fixes ahead of the official VS 2026 launch at .NET Conf. | Visual Studio Magazine [visualstudâŚgazine.com] |
| Azure SDK â Oct 2025 | October 27, 2025 | Azure AI Foundry 1.0 for .NET released (manage AI projects/agents on Azure) [devblogs.mâŚrosoft.com]; Azure Identity libraries prepped for mandatory MFA changes; improvements to Azure AI Search (vector queries, semantic ranking) and other cloud service SDKs. | Azure SDK Blog (R. Geraghty) [devblogs.mâŚrosoft.com] |
| Semantic Kernel & Agent Framework (AI Preview) | October 1, 2025 (preview) | Microsoft introduced the Agent Framework (Preview) â a .NET library to build and orchestrate AI agents with minimal boilerplate [devblogs.mâŚrosoft.com]. Built on Semantic Kernel and Microsoft.Extensions.AI, it enables complex multi-step AI workflows in .NET. Community AI libraries like LLamaSharp (for local LLMs) and Whisper.NET (speech-to-text) also gained visibility. |
.NET Blog (L. Quintanilla) [devblogs.mâŚrosoft.com] |
.NET 8 & .NET 9 Security Updates: On October 14, 2025, Microsoft issued its regular Patch Tuesday servicing releases for supported .NET versions. .NET 8.0.21 (LTS) and .NET 9.0.10 (STS) were released simultaneously, delivering the latest security fixes and reliability improvements. Notably, multiple vulnerabilities were addressed this month â including an information disclosure, a security feature bypass, and a denial-of-service issue affecting .NET 8/9. (One of these, CVE-2025-55315, was a HTTP/HTTPs request smuggling vulnerability that researchers highlighted as particularly severe, now patched in this update.) As expected, these servicing releases did not introduce new features or breaking changes. Developers running .NET 8 or .NET 9 in production should upgrade to 8.0.21/9.0.10 to ensure their apps have the latest security hardening. The updates also included a security roll-up for .NET Framework 4.8/4.8.1, addressing a remote code execution flaw in the legacy framework. In summary, keeping up with these October patches is critical, as they resolve some high-priority vulnerabilities while keeping the platform stable. [devblogs.mâŚrosoft.com]
.NET 10 Release Candidate 2: The headline this month was the delivery of .NET 10 RC2 on October 14, 2025 â the final release candidate for .NET 10 before its general availability in November. RC2 follows Septemberâs RC1, and like RC1 it comes with a âgo-liveâ support license (meaning early adopters can run it in production with Microsoft support). The official release date for .NET 10 is November 11, 2025 (coinciding with .NET Conf 2025), at which point it will become a Long-Term Support (LTS) release with 3-year support. As expected for a final RC, .NET 10 RC2 did not add any new features in the runtime, libraries, or languages â itâs all about final polish, performance tuning, and fixing remaining bugs. The .NET team emphasized that RC2âs goal was to ensure a smooth upgrade path to .NET 10 for everyone, so they focused on validation and stability rather than new functionality. [infoq.com] [infoq.com], [infoq.com] [infoq.com], [github.com]
Runtime & SDK: RC2 finalizes a few under-the-hood improvements. For example, it includes the completion of a long-awaited MSBuild enhancement: developers can now author .NET-based MSBuild tasks that run inside Visual Studio (and msbuild.exe) without needing .NET Framework-specific builds. In RC2, the SDK supports marking tasks with Runtime="NET" and uses a new TaskHost mechanism to run them in the VS process. This closes a gap in build extensibility and is part of a broader effort to modernize MSBuild for cross-platform use. Other than that, the SDK and tools in RC2 mostly received minor tweaks and documentation updates. The C# and F# compilers had no changes (C# 14 is feature-locked at this point), and .NET 10âs core libraries are API-complete. In short, if you tried any of the earlier previews, RC2 should feel nearly identical, just more robust and refined. [infoq.com] [github.com]
ASP.âNET Core & Blazor: Since RC2 introduced no new API features, the web stack in .NET 10 is essentially in its final form. The teamâs efforts went into fixing issues and ensuring compatibility. For instance, minor polish was added to Blazor and minimal APIs following feedback from RC1 â but nothing headline-worthy, as most web features (like improved authentication options and OpenAPI support) were already done by Preview 7/RC1. One thing to note: ASP.NET Core Identityâs new metric collection (counters for auth events) and Blazorâs persistent component state â both introduced in RC1 â were tested extensively and remained stable in RC2. So, developers can confidently start using those in preparation for .NET 10. The lack of new changes in RC2 for ASP.NET Core signals that the framework is ready for prime time. [manorrock.com]
.NET MAUI (Mobile/Desktop): .NET 10 RC2 brought a number of refinements to .NET MAUI, underscoring Microsoftâs push to make MAUI production-ready for LTS. Some improvements are platform-specific: on Windows, MAUI apps now have proper support for microphone permissions via a unified API (aligning with how Android/iOS handle permissions). On Android, RC2 introduced support for API level 36.1 (Android 16 âUpsideDownCakeâ) â meaning developers can target the latest Android SDK out-of-the-box. This work was done in partnership with the Uno Platform team, who collaborated deeply with Microsoft to integrate Android 16 bindings into MAUI. Thanks to Unoâs contribution, .NET 10âs Android tooling was updated in record time, allowing devs to use the newest Android features immediately. Microsoft publicly thanked the Uno Platform engineers for this collaboration, highlighting how community-driven efforts strengthened MAUIâs cross-platform support. In addition, RC2 includes enhancements to XAML Hot Reload and XAML compilation. The new XAML Source Generator (introduced in preview) was further optimized, improving build-time XAML validation and reducing app startup times. Developers should see more reliable hot-reload experiences when tweaking UI, and generated code for XAML is leaner. Other MAUI tweaks: SafeAreaEdges on Android for better layout on devices with notches or gesture bars, and updated Xcode 16/17 support for iOS/macOS, ensuring that .NET 10âs iOS/tvOS targets work with Appleâs latest SDKs. All these changes are incremental, but together they make MAUI apps more polished and ready for .NET 10 GA. [infoq.com], [infoq.com] [infoq.com] [visualstudâŚgazine.com]
Entity Framework Core 10: EF Core 10 had already lit up major features (like JSON columns and vector search support) earlier in the preview cycle. By RC2, the EF team focused on stability and fit-and-finish. RC2 incorporated a batch of bug fixes and performance improvements for EF Core â for example, more robust support for complex/owned types inside JSON documents (resolving edge cases when mapping nested objects to SQL JSON columns). They also fine-tuned the execution strategy (automatic query retries) so that it now transparently handles transient errors even during LINQ query materialization. A nice addition in RC2: EF Core now issues analyzer warnings for raw SQL usage that involves string concatenation. This helps catch potential SQL injection risks at compile time â if a developer naively builds a SQL string with user input, the analyzer will flag it. This isnât a new feature per se (just an SDK analyzer tweak), but it underscores EFâs focus on safety and best practices. Aside from that, EF 10âs new capabilities (like mapping to SQL Serverâs VECTOR type for AI embeddings, and improved Cosmos DB support) were essentially final by RC1. No breaking changes were introduced in RC2. For those planning migrations, itâs a good sign: EF Core 10âs behavior is now locked in, and any code working on RC2 should work on the final 10.0 release. [infoq.com]
Overall, .NET 10 RC2 gave the community a last chance to validate their apps on the new runtime before the official launch. Early adopters are encouraged to test their projects with RC2 and report any issues. Given the minimal differences from RC1, most found the upgrade trivial, and many companies started deploying RC builds to staging environments to get a head start on .NET 10âs performance benefits. The excitement is building for the imminent release â with RC2 out, the stage is set for .NET 10âs GA in November, which will bring the first new LTS runtime since .NET 8 in 2023.
Developer tooling in October 2025 continued to advance, particularly in anticipation of .NET 10. Microsoftâs flagship IDE and related tools received updates aligning with the new runtime and introducing more AI-powered features into the development workflow.
Visual Studio 2026 Insiders Preview: The next major Visual Studio version, informally dubbed VS â2026â, has been in Insiders Preview for a couple of months (since early September). In October, Microsoft rolled out an updated Visual Studio 2026 Insiders build (Preview 3) that fully supports .NET 10 RC2 development. This means if you had the Insiders IDE, you could open, build, and run .NET 10 projects seamlessly â perfect for trying RC2. The VS 2026 Insiders channel is all about AI integration and performance. By October, testers reported a snappier experience (solution load times improved further compared to the initial preview) and deeper GitHub Copilot features woven throughout the IDE. Many of the âAgentic AIâ capabilities we discussed last month are evolving: the AI âProfiler Agentâ in VS can now not only explain performance issues but also automatically apply some suggested fixes, and the Copilot-powered âModernizeâ tool (which helps upgrade older projects) saw refinements in the Insiders build (e.g. better handling of config files). Essentially, VS 2026 is shaping up to be an AI-first IDE, with Octoberâs preview tightening up reliability. The UI/UX of VS 2026 also got minor tweaks from user feedback â some testers noticed cleaner dark mode theming and more fluid animations when Copilot inserts code. Itâs worth noting that Visual Studio 2022 is still the mainline IDE for most developers; Microsoft backported a number of AI features to VS 2022 v17.14 last month. In October, VS 2022 did not have a new major update (the next expected update, 17.15, is aligned with .NET 10 GA in November). So, current VS 2022 users continued with 17.14âs enhancements, while those adventurous enough tried VS 2026 Insiders for the cutting edge. Microsoft has been advertising .NET Conf (Nov 11-13) as the big reveal for Visual Studioâs future â indeed, they plan to officially unveil Visual Studio 2026 (likely as VS18) there. In preparation, Octoberâs Insiders preview was all about stomping out bugs and ensuring day-one support for .NET 10, C# 14, and F# 8. If youâre interested in the latest IDE features, the Insiders build is quite usable at this point â just expect frequent updates as the team responds to feedback ahead of General Availability. [github.com], [github.com]
.NET CLI & SDK Tools: Alongside the core runtime, various SDK tools saw final updates pre-.NET 10. The dotnet CLI in RC2 is effectively the release version, so no changes will come until patch 10.0.1. One small but notable tool change: .NET 10âs SDK includes the experimental dnx global tool runner (which first appeared in Preview 7) â by RC2 this tool was documented and ready for devs to try using dotnet dnx <tool> as an alternative way to invoke local tools (though it remains optional and experimental). Also, those using C# Dev Kit in VS Code got an update: by mid-October, the C# Dev Kit extension for VS Code had added full support for .NET 10 RC features (like new C# 14 syntax and project templates). The Dev Kit, which had been in preview for months, is very close to a 1.0 release. In fact, many expect Microsoft to declare it stable at .NET Conf. Octoberâs version ironed out OmniSharp server issues and improved IntelliSense around some of the new .NET 10 APIs. This is great for developers preferring VS Code, as it means a lightweight editor can handle the latest .NET with ease. [manorrock.com]
On the project upgrade front, no new releases of the .NET Upgrade Assistant occurred in October (the last big update was earlier in the summer). However, the integration of upgrade tooling into Visual Studio continued as a theme. As mentioned, VS 17.14 introduced the Copilot âModernizeâ agent. In October, more users tried it out on real projects. Early feedback was positive â reports came in that even complex ASP.NET MVC apps could be partially converted to ASP.NET Core automatically. The process isnât one-click â but the tool would, for example, create new project files, convert web.config to appsettings.json, stub out controllers in the new ASP.NET Core style, and then Copilot would step in to fix smaller code issues. Several developers blogged that combining Upgrade Assistant and Copilot saved significant time on migrations (weâll touch more on that in the Modernization section). So, tooling-wise, Microsoft has effectively blended the line between âIDE featuresâ and âAI assistanceâ â a trend fully on display this month.
Azure SDK and Cloud Tooling: Microsoft releases updates to the Azure SDKs monthly, and the October 2025 Azure SDK release had some interesting tie-ins with the .NET world. The headline was a preview of mandatory MFA (multi-factor auth) support in the Azure Identity libraries. Microsoft is planning to enforce MFA for Azure AD tenants in 2026, and in Octoberâs SDK update they urged developers to prepare for the impact on auth flows. In practice, newer Azure SDK versions for .NET are adding hooks so that if MFA is required, the library can interactively prompt or use cached tokens appropriately. This is more of a forward-looking note, but enterprise .NET devs should be aware that how they get Azure credentials will evolve (no more relying solely on single-factor secrets). On a more dev-centric note, the Azure SDK team shipped the first stable release of âAzure AI Foundryâ libraries for .NET. Azure AI Foundry 1.0.0 is a new offering that provides programmatic access to Azureâs AI Foundry service â essentially letting .NET developers create and manage AI projects and agents on Azure easily. With this library, you can deploy AI models, set up vector indexes for semantic search, orchestrate AI Agents, and connect to other Azure resources, all from C# code. This aligns with the on-prem Agent Framework (more on that later) but for cloud-hosted scenarios. Itâs interesting because it shows Microsoft bringing the âAI agentsâ concept to Azure, and giving .NET devs first-class tools to leverage it. Also in the Azure SDK update: Azure Cognitive Search got enhancements (the JavaScript and Python SDKs were highlighted with support for a new API version that includes vector search on sub-fields, semantic reranking improvements, and lexical normalizers â these likely reflect similar capabilities coming in the .NET Azure.Search library). In short, Azure is doubling down on vector databases and hybrid search (text + vectors), which is crucial for building AI-powered apps. .NET developers using Azure Search will soon (if not already) be able to run more advanced queries â great for scenarios like semantic search and AI-driven data retrieval. Lastly, Azure Container Apps and Azure Functions updates (noted in Azure blogs) now fully support .NET 10 â though .NET 10 was not yet GA in October, Azure teams pre-provisioned support so that as soon as .NET 10 launches, you can deploy Functions or Container Apps with it. All these cloud tooling tweaks ensure that the moment .NET 10 goes live, the ecosystem (Azure, VS, CI/CD pipelines, etc.) will be ready to support it. [devblogs.mâŚrosoft.com]
Other Tools & Ecosystem: In the broader .NET tool ecosystem, October didnât bring dramatic shifts but there are a few points of note. JetBrains Rider 2025.3 EAP continued to track .NET 10âs development â by late October their early-access build had polished support for C# 14 and .NET 10 RC2, ensuring that alternative IDE users could also work with the latest tech. JetBrains also followed through on performance improvements for ReSharper (as discussed last month); some users on VS 2022 reported significantly fewer UI freezes with the latest ReSharper nightly builds, which is encouraging for those who rely on its deep analysis. On the CI/CD front, GitHub Actions updated their virtual environments in October: the windows-2022 and ubuntu-latest runners now include .NET 10 RC2 SDK, so automated builds could target .NET 10 even before GA. This was handy for library authors preparing nuget packages for .NET 10 â they didnât have to manually install the preview SDK on CI. Also, dotnet-monitor (the diagnostics tool for capturing app metrics and traces in production) released v8.2, which added preliminary support for .NET 10 processes, ensuring that new runtimeâs event counters and GC stats are properly exposed. All these are minor version bumps, but they collectively signal a readiness in the toolchain for .NET 10âs arrival.
Modernizing older .NET applications remains a significant theme as we approach the end of 2025. With .NET 10 (LTS) about to launch and .NET 6 reaching end-of-life in just a few months (early 2026), many organizations are accelerating plans to move legacy apps to the latest .NET. October didnât introduce brand-new migration tools, but it showcased how the tools and guidance put in place over the past year are helping real projects, and it reinforced Microsoftâs messaging: Now is the time to modernize.
Copilot-Powered Upgrades in Practice: Last month, the GitHub Copilot âapp modernizationâ extension graduated into Visual Studio 2022 (as the @modernize Copilot chat agent). In October, more developers gave it a spin on their legacy codebases. The experience has been described as âpair programming with an expert robot thatâs done 100 migrations.â For example, a team migrating a large ASP.NET MVC 5 app (circa 2014) to ASP.NET Core shared their process: they ran the .NET Upgrade Assistant to do the initial project file and package conversion, then used the Copilot modernize agent to interactively fix remaining issues. The tool flagged web.config usage â Copilot suggested moving certain configs to appsettings.json and even generated the initial JSON. It found places where System.Webâs Membership was used for auth and guided replacing it with ASP.NET Core Identity. Perhaps most impressively, it detected custom HTTP handlers and helped convert them into ASP.NET Core middleware classes. The devs noted that about 70% of the tedious code changes were handled by the toolset, leaving them mainly with testing and a few complex refactoring tasks. This is a big leap from a year ago, where such a migration would be almost entirely manual coding. It demonstrates that AI assistance can significantly reduce the pain of uplift. The combination of rule-based and AI-based tools means even tricky parts (like replacing old WCF service calls with gRPC or Azure Functions) are at least partially automated â Copilot might not complete it perfectly, but it provides a solid starting point.
Community Guidance & Success Stories: The community and Microsoft continued to publish guidance to encourage upgrades. In early October, a Microsoft Dev Blog post reminded that .NET 9 support was extended to 24 months (STS support policy change) â meaning .NET 9 is supported until Nov 2026 now. This gives .NET 9 users a bit more breathing room, but the .NET team still nudges folks towards .NET 10 if possible, since it will be the LTS. A detailed case study emerged on a tech blog about migrating a large Windows Forms app from .NET Framework 4.7 to .NET 8. Using Upgrade Assistant in âin-placeâ mode, they converted hundreds of projects automatically. One interesting tip from that story: they leveraged a new Interoperability shim (a community NuGet) that implements parts of System.EnterpriseServices so that even old COM+/Transaction code could run on .NET 8 â demonstrating that for almost every blocker, someone has built a workaround to help modernization. The Argon Systems blog (which often covers .NET infrastructure) published a follow-up piece based on Build 2025 content, outlining a checklist for combining Upgrade Assistant + Copilot. It reiterated best practices like: run the automated upgrade tool first, then use Copilot on the diff to resolve TODOs; always have a comprehensive test suite to verify behavior remains correct; and consider splitting huge monoliths into smaller pieces during the upgrade (since youâre already refactoring, it might be a good time to introduce a more modular architecture). [manorrock.com] [manorrock.com], [manorrock.com]
Pushing to Cloud as Part of Modernization: Microsoft also tied modernization with cloud adoption in messaging this month. At their Ignite planning sessions (some details trickled out ahead of the November conference), they highlighted how upgrading to .NET 8/10 and moving to Azure often go hand-in-hand. The idea: an app freed from the old .NET Framework can more easily run in Azure App Service or containers. The Copilot modernization tool itself has specific logic for Azure (like suggesting Azure Blob Storage in place of file system, or Azure Cache for old AppFabric cache). In October, Microsoft updated the docs for Azure App Service Migration Assistant to explicitly mention .NET â it checks your site and if itâs .NET Framework, it will recommend running Upgrade Assistant first. The synergy between modernization and cloud is so strong that cloud solution providers (like Mobilize.net) have started offering âone-stop shopâ migration services: theyâll use the automated tools to upgrade the tech stack and then containerize the app for Azure Kubernetes or package it for Azure Functions if appropriate.
In short, modernization efforts in October 2025 continued apace, driven by both tools and urgency. We didnât see new versions of migration tools this month (since theyâre already mature), but we did see their real-world impact. The consensus among experts: donât wait. If you have legacy .NET apps (be it Web Forms, WCF, old WinForms, etc.), the path to .NET 8 or 10 has never been clearer. And with .NET 10 about to become the new baseline, now is the perfect time to make the leap. The tooling from this year (Upgrade Assistant improvements, VSâs integrated Copilot, breaking change analyzers) has significantly de-risked the process. Many companies are seizing this moment to future-proof their software, ensuring they can run on modern infrastructure, benefit from performance gains (often 30-50% throughput improvements just from moving to .NET Core runtimes), and integrate new capabilities (like span memory, latest C# features, and cloud services). If youâre still on .NET Framework 4.x or even .NET Core 3.1, the message is clear: the modern .NET train is leaving the station â time to get on board!
Beyond official releases, the .NET ecosystem was buzzing in October with community contributions, library updates, and events. Here are some highlights across various areas of the .NET world:
Cross-Platform & Client Development: A notable story this month was the collaboration between the Uno Platform and Microsoft to enhance .NETâs cross-platform UI stack. As mentioned earlier, Uno (an open-source XAML/C# UI framework) worked closely with the .NET MAUI team to implement Android API level 36 support in .NET 10 RC2. This collaboration not only ensured day-one support for Android 16 in .NET MAUI, but it also fostered a stronger relationship between first-party and third-party framework maintainers. Unoâs team spent over six weeks jointly engineering with Microsoft, contributing changes to .NETâs Android bindings and toolchains. In a companion blog post, Uno Platform detailed how they helped update the binding infrastructure for the new SDK and plan to continue assisting with things like WebAssembly threading support and co-maintaining SkiaSharp (the graphics engine used by both Uno and MAUI). This is a great example of open-source community input directly improving .NET â and it means developers using .NET MAUI or Uno can expect more seamless experiences and faster access to new native features. [visualstudâŚgazine.com]
On the web side, Blazor continues to mature quietly. With .NET 10âs release, Blazor Server and WebAssembly are getting small stability improvements (like the persistent component state feature and better prerendering support we discussed). The community remains excited about Blazorâs trajectory â especially the promise of Blazor United (a unified rendering model) presumably coming post-.NET 10. While that didnât materialize in October, community experiments popped up combining Blazor with other tech: for instance, a GitHub project surfaced integrating Blazor WebAssembly with WASI (WebAssembly System Interface) to run some server logic on the client. Itâs bleeding edge, but shows .NET devs are exploring new frontiers in web deployment models. Meanwhile, traditional ASP.NET Core usage is strong â several community blogs this month focused on ASP.NET Core best practices. One series that stood out was by Khalid Abuhakmeh, who did a deep dive on output caching in minimal APIs, showing how to use the new output-cache middleware coming in .NET 10 to drastically improve performance for certain GET endpoints (in one case, they achieved a 10x throughput boost for cacheable responses). Itâs encouraging to see community members dissecting these features and demonstrating real use cases.
Packages & Libraries: The NuGet ecosystem had a quieter month (no bombshell package announcements), but there were a few noteworthy updates:
Microsoft.Extensions.AI package (introduced as part of the Semantic Kernel toolkit) reached a stable-ish state. This library provides common interfaces for AI services (chat completion, embeddings, etc.), and in October it was updated alongside the Agent Framework preview. Weâll talk more about it in the AI section, but itâs basically Microsoftâs attempt to standardize AI service access in .NET.We also saw continued adoption of NuGetâs âTrusted Publishingâ feature (which rolled out in September). By October, many popular .NET OSS projects had switched their CI pipelines to use short-lived tokens instead of static API keys when pushing packages. For example, the maintainers of Serilog and AutoMapper both tweeted that they enabled Trusted Publishing via GitHub OIDC â a good sign for supply chain security in .NET. This feature, which lets GitHub Actions obtain a one-time NuGet push token, significantly reduces the risk of package tampering, and itâs great to see it catching on. [manorrock.com]
Cloud & Services Integration: .NETâs integration with cloud services continued to deepen. This month, we already covered Azureâs SDK updates (AI Foundry, Search, Identity). In addition, AWS quietly released an update to their .NET deployment tooling: the AWS Toolkit for Visual Studio gained support for .NET 10 projects (so you can deploy .NET 10 Lambda functions or Beanstalk apps from VS as soon as .NET 10 is out). AWS also published refreshed .NET Orleans documentation for their cloud, reflecting how to run the Orleans distributed actor framework on AWS Orleans clusters â noteworthy because Orleans 7 (released earlier this year) made it easier to use in any cloud, and AWS is ensuring .NET devs know theyâre welcome on their platform too. Over in the gRPC community, an interesting development: Google announced an experimental gRPC-Web for .NET library, enabling .NET servers to directly support gRPC-Web protocol without a proxy. Itâs in preview, but the ability to call gRPC services from browser JavaScript (which only speaks HTTP/1.1) without needing the usual Envoy proxy is a big win, and .NET might be one of the first to get this baked in thanks to a collaboration between the gRPC team and .NET team.
Third-Party Tools: Weâve mentioned JetBrains already; another third-party tool that got attention is Postman â the popular API testing tool. Postman released a new .NET collection runner so you can integrate API tests into .NET build pipelines more easily. They also provided an updated version of their Swagger/OpenAPI codegen that targets .NET 8/10 minimal APIs (essentially generating minimal API controllers from OpenAPI specs). This shows that even outside the core .NET world, the tool ecosystem is adapting to the new styles and versions of .NET quickly.
The .NET developer community was very active in sharing knowledge throughout October. Here are a few content highlights and open-source projects that made waves:
Blog Posts & Series: Several long-running blog series reached their conclusions as .NET 10 neared release. Notably, Andrew Lockâs excellent series âExploring the .NET 10 previewâ hit Part 8 and 9 this month. In Part 8, Andrew tackled an interesting new attribute in .NET 10 â UnsafeAccessorAttribute â which makes reflection-based serialization faster by letting the runtime skip certain safety checks. His deep-dive explained how this attribute, when applied to properties, allows libraries like System.Text.Json to set private members more directly, improving performance. In Part 9, Andrew switched gears to security, writing âUnderstanding the worst .NET vulnerability ever â CVE-2025-55315â. This post broke down the HTTP/2 request smuggling flaw that was fixed in the October patches, showing how a malformed request could bypass ASP.NETâs checks and smuggle forbidden headers. It was a timely piece â not only explaining the exploit in an accessible way, but also reminding everyone to apply the October updates. Andrewâs series as a whole has been a fantastic resource for .NET devs prepping for the new release.
Videos & Podcasts: The official https://www.youtube.com/dotnet hosted a few interesting live sessions in October. One was âAll About ASP.NET Core Middlewareâ, where two Microsoft engineers built a custom middleware from scratch on stream, demonstrating new features in the middleware pipeline in .NET 10. Another was an episode of On .NET Live titled âML.NET in 2025: Machine Learning for .NET Developersâ â aligning with our AI theme, this episode showcased how far ML.NET has come (with things like TorchSharp integration for deep learning tasks). On the community side, YouTube content continued strong: for example, Nick Chapsas, a well-known .NET YouTuber, put out a video âI converted a 20-year-old Web Forms app to Blazor â hereâs what happenedâ. It was part educational, part entertaining, highlighting challenges in migrating UI frameworks (spoiler: the demo worked, but not without some hacks). Also, short-form videos remained popular on Twitter (X) and TikTok; we saw a few 60-second tips like â3 hidden gems in LINQâ and âC# 14 in a nutshellâ that got shared widely. Itâs great to see bite-sized .NET tips reaching a broader audience.
await Retry.Do(async () => {...}).WithExponentialBackoff().MaxRetries(3); with very readable fluid style. It sparked discussion on Reddit about whether we need yet another retry library, but itâs always good to have competition (and itâs quite lightweight).In summary, the .NET community in October 2025 was vibrant and engaged. We saw open-source collaborations bearing fruit (Uno + MAUI), a plethora of knowledge sharing (detailed blogs and videos), and anticipation building for the major releases ahead. The ecosystem feels ready for the big changes â .NET 10 and the wave of AI tooling â and is simultaneously keeping older platforms (like F# and older app frameworks) well-supported. Itâs a good time to be a .NET developer: whether youâre building web APIs, cloud services, mobile apps, or experimenting with AI, the community has resources and tools to support you.
One of the most exciting trends in 2025 is the convergence of AI and .NET development. October 2025 underscored this trend, with significant updates and community efforts focused on integrating AI/ML capabilities into .NET applications. From machine learning frameworks to libraries for large language models (LLMs) and new AI-focused SDKs, .NET developers now have a rich arsenal to infuse intelligence into their apps. In this section, weâll highlight the key AI integration points in the .NET ecosystem and whatâs new or notable for each:
Official ML/AI Libraries (ML.NET and More):
ML.NET, Microsoftâs flagship machine learning framework for .NET, continues to evolve as a comprehensive tool for training and using custom ML models in C# or F#. Over the past year, ML.NET reached version 4.0, and it now covers a wide array of scenarios â not just classical ML but also some deep learning tasks. For example, ML.NET 3.0 (late 2023) added support for deep learning tasks like object detection and question answering by integrating TorchSharp (a .NET wrapper for PyTorch) under the hood. And in ML.NET 4.0, the team improved the Microsoft.ML.Tokenizers component (used for NLP models) with support for modern tokenization schemes like TikToken (for GPT models) and added compatibility with popular models like LLaMA. What this means: .NET developers can train or fine-tune vision and NLP models in-process, or use ML.NETâs AutoML to find the best model, all without leaving the .NET ecosystem. October didnât bring a new ML.NET version, but it did bring community attention to ML.NETâs capabilities â the âML.NET in 2025â live stream showed how you can use ML.NET to build a sentiment analysis model and then export it to ONNX for production use, a very relevant scenario. The ONNX Runtime for .NET is another pillar: it allows running pre-trained models (from TensorFlow, PyTorch, etc., converted to ONNX format) highly efficiently in .NET. In fact, ONNX Runtime is what powers features like Windowsâs offline speech recognition, and itâs useful if you want to, say, run a vision model in a .NET MAUI mobile app. One question that came up recently (on Stack Overflow and elsewhere) is AOT compatibility of ONNX in .NET; as of .NET 8, ONNX Runtime wasnât fully AOT-friendly, but there are indications that by .NET 10, this is being improved â important for scenarios like iOS where you need AOT compilation. [learn.microsoft.com]
AI Services and SDKs (Azure & Beyond):
On the cloud side, .NET has first-class SDKs for AI services. The Azure AI SDKs for .NET include Azure Cognitive Services (vision, speech, language APIs) and Azure OpenAI (which provides access to GPT-4, GPT-5, etc. in the cloud). In October, as noted, the Azure AI Foundry SDK 1.0 was released for .NET. Azure AI Foundry is a new Azure service that allows companies to host and orchestrate multiple AI models and agents centrally. With the .NET SDK, developers can programmatically deploy AI models (like uploading a custom model or enabling an OpenAI model), create âAI Projectsâ that might link a model to a vector index (for semantic search), and even execute agent workflows. This essentially brings some capabilities of Semantic Kernel/Agent Framework into a managed cloud service. For .NET devs, it opens possibilities: you could write C# code to spin up an AI agent in Azure that uses, say, a GPT-4 model + your custom knowledge base, then call that from your application as needed. Speaking of Semantic Kernel (SK), although not brand-new, it remains a key open-source library for orchestrating AI in .NET. SK provides a high-level API to connect to LLMs (Azure or local), define âskillsâ (code functions that the AI can invoke), manage memory (embeddings), and even do planning (chain of thought for multi-step tasks). In 2025 SK has matured significantly; by October itâs compatible with all the latest .NET pieces and itâs used behind the scenes in the Agent Framework. Many community projects leverage SK â for example, a popular sample on GitHub called âDocument Summarizer with SKâ shows how to use SK to read a bunch of PDFs and have GPT generate summaries, all within a .NET console app. Itâs worth noting that SK is also integrated with Microsoft Extensions for AI. [devblogs.mâŚrosoft.com]
A huge development in October was the introduction of the Microsoft âAgent Frameworkâ (Preview) for .NET. This deserves emphasis: Agent Framework is an open-source set of libraries to build AI agents in .NET easily. It sits on top of Semantic Kernel and AutoGen (another MSR library for multi-agent systems) and essentially gives you a straightforward way to create an agent that can use reasoning (LLMs), maintain context, and invoke tools (like call APIs or run code). The Agent Framework reduces a lot of boilerplate â as the blog post says, you can build, orchestrate, host, and monitor agents with familiar patterns. For example, with a few lines of code, you might set up an agent that given a customer question, decides to either answer from a knowledge base or create a support ticket via an API (using the âtoolsâ concept). This preview was announced on Oct 1 and generated a lot of excitement. It aligns with the AI Assistant features in VS as well (which are essentially agents controlling the IDE). The fact that .NET now has a dedicated framework for agents means .NET could become a go-to platform for building AI-driven backend services (since developers can use their C# skills to orchestrate complex AI behavior). Itâs still early days (preview packages on NuGet), but definitely something to watch. [devblogs.mâŚrosoft.com]
AI/ML Open-Source in .NET:
Beyond Microsoftâs offerings, the community has produced numerous libraries to integrate AI in .NET. Hereâs a quick overview of some key AI-related OSS projects in the .NET ecosystem and their purposes:
| Library / Tool | Purpose & Highlights |
|---|---|
| ML.NET | Machine Learning framework for .NET â train custom models (classification, regression, recommendation, image, NLP). Includes AutoML and integration with ONNX/TorchSharp for deep learning [learn.microsoft.com], [learn.microsoft.com]. |
| ONNX Runtime .NET | Run pre-trained ML/DL models (ONNX format) with high performance in .NET applications. Great for leveraging models from Python (TensorFlow/PyTorch) in production .NET (supports CPU, GPU). |
| Semantic Kernel | SDK to orchestrate Large Language Models and tools. Allows composing AI plugins, managing memory (embeddings), and planning multi-step tasks in .NET. Forms the basis of many AI workflows in .NET. |
| Microsoft Extensions.AI | New extension libraries providing standardized interfaces and helpers for AI (e.g. IChatClient, IEmbeddingGenerator). Enables swapping between providers (OpenAI, Azure OpenAI, local LLM) behind a common API [amarozka.dev], [amarozka.dev]. Makes AI integration more plug-and-play in .NET. |
| LLamaSharp (SciSharp) | Open-source library to run Large Language Models (LLMs) like LLaMA locally in .NET, leveraging CPU (and experimental GPU) backends. Lets you have a ChatGPT-like model running offline in a C# app. Active development (supports LLaMA2/3, quantized models). |
| Whisper.NET | .NET wrapper for OpenAIâs Whisper model (speech-to-text). Enables high-quality transcription of audio to text entirely in .NET (using ONNX or local GGML models). Useful for voice-enabled .NET applications. |
| Vector DB Clients | .NET SDKs for vector databases (like Pinecone, Redis Vector, Qdrant). These allow storing and querying embeddings for semantic search. Often used alongside Semantic Kernel or custom AI solutions for memory. |
Many of these projects saw activity in October. For instance, LLamaSharp released v0.25 with better performance on .NET 8 and support for the new Llama2 70B model (if you have the compute for it). Developers are using LLamaSharp to build chatbots that run on their local machines â a great example of .NET being used for cutting-edge AI without cloud dependency. Microsoft.Extensions.AI is now being adopted in various libraries; the Agent Framework preview uses it to abstract model providers. This means if you build an agent with their framework, you can swap between, say, OpenAIâs GPT-4 (hosted) and LLamaSharp (local) by just changing the registered IChatClient implementation, which is pretty powerful for testing or on-prem scenarios. [devblogs.mâŚrosoft.com] [amarozka.dev], [amarozka.dev]
Furthermore, community-driven AI frameworks like TorchSharp (which exposes PyTorch to .NET) and SciSharp STACK (which includes libraries like NumSharp, Keras.NET, etc.) continue to mature. TorchSharp in particular saw some contributions to support more vision models easily. And on the research front, thereâs even an experimental F# project named âFirebirdâ exploring bringing differentiable programming to .NET for neural nets â niche, but shows that even in the academic AI space, .NET is being considered.
Use Cases Blossom: All these tools are not just theoretical â people are building cool stuff. In Octoberâs Global AI Hackathon, one team built an âAI DevOps Assistantâ entirely in .NET: it used Semantic Kernel to wrap Azure DevOps APIs so you could ask in natural language for things like âdeploy the latest build to stagingâ and it would execute the pipeline. Another example: a plugin for Outlook (in .NET) that uses Whisper.NET to listen to meeting audio and Semantic Kernel with GPT to generate meeting minutes in real-time â effectively bringing Copilot-like functionality to Outlook via a VSTO add-in. These projects show the imagination of developers now that the barriers to AI (lack of libraries, complexity) are falling within .NET.
In summary, .NETâs AI integration ecosystem in October 2025 is thriving. Microsoft is providing the building blocks (ML.NET, ONNX, Semantic Kernel, Agent Framework) to enable both traditional ML and modern AI scenarios in .NET. The community is supplementing this with open-source libraries that cover everything from running large models locally to connecting to external AI services. The key takeaway for .NET developers: you no longer have to leave the .NET world or learn Python to incorporate AI into your apps. Whether you need a simple predictive model, a full conversational bot, or an AI agent automating tasks, thereâs likely a .NET library or service to help you. Octoberâs releases and content made it clear that AI is becoming a first-class citizen in the .NET ecosystem, heralding a new era of intelligent applications built on .NET.
As we wrap up the October 2025 Pulse, itâs worth peeking at whatâs just around the corner for .NET developers:
.NET 10 Launch at .NET Conf 2025: The big event is imminent â .NET 10 (STS) will be officially released at .NET Conf, running November 11â13, 2025. This three-day virtual conference will showcase all the new advancements in .NET 10 and the broader ecosystem. Day 1 keynotes will not only announce .NET 10 GA (with its final build number likely 10.0.0) but also unveil Visual Studio 2026 formally. We expect a deluge of content: demos of .NET 10âs performance gains, deep dives into C# 14 features, and sessions on using .NET 10 for cloud-native apps, MAUI, gaming, IoT, you name it. Since .NET 10 is an LTS, adoption will be high â so a lot of guidance will be about upgrading to .NET 10, best practices for new APIs, etc. If the previews are any indicator, performance will be a highlight (we anticipate a segment quantifying how .NET 10 is faster than .NET 8 in various benchmarks, as each release brings improvements). Keep an eye out for surprise announcements too â perhaps a sneak peek of .NET 11 (planned for late 2026) or news on Unity (the game engine) moving to a newer .NET Core runtime, which has been a long time coming.
Visual Studio 2026 and AI in the IDE: Alongside .NET 10, Microsoft will likely launch Visual Studio 2026 (v18) or at least a near-final version. This is expected to be the most AI-infused IDE ever. One teased feature is âAgent Chatâ in VS: a Copilot chat that can not only suggest code but also execute tasks (the so-called Agent Mode). We saw hints of this in previews; perhaps at .NET Conf theyâll demo something like âAsk the IDE to set up a CI pipelineâ and watch it edit YAML, commit files, etc. Also, VS 2026 promises improvements for C++ and other workloads, but for .NET devs the big deal is integration with .NET 10 and making us more productive through AI. By mid-November, we should have a clear picture of how soon VS2026 will be generally available and how VS2022 users can transition. (Microsoft did reassure that VS2022 will remain supported for a while, but all the cool new toys will be VS2026+ only.)
Entity Framework 10 & Minor Releases: With .NET 10 out, weâll also get EF Core 10 GA. The EF team might also talk about their next steps â possibly an EF Core 10.1 or 11 preview with features that didnât make the cut (some rumors include better JSON indexing and bulk updates). Additionally, ASP.NET Core will likely post a roadmap for the next year. Sometimes the ASP.NET team uses .NET Conf to mention whatâs coming in the minor updates (like ASP.NET Core 10.1, etc.), which could include things like improved gRPC-Web (if not already done) or Blazor WebAssembly multi-threading support status.
AI and .NET Roadmap: Expect more clarity on Microsoftâs AI roadmap for .NET. The Agent Framework is in preview â we might hear about when it will go stable and how it ties into Azureâs offerings. Also, keep an ear open for âCopilot for Enterprisesâ type announcements: e.g., hosting the Copilot LLM on-prem or fine-tuning it â something many enterprise .NET shops would be interested in for regulatory reasons. It wouldnât be surprising if Microsoft launched more AI services that plug into .NET (like a vector database service on Azure, or expansions of Cognitive Services).
Support Transitions: With .NET 10âs release, .NET 7 officially goes out of support (as it was an STS that expired after 18 months) in early November. So any stragglers on .NET 7 will need to move to .NET 8 or 10. Microsoft will probably reiterate this in blogs and at .NET Conf. Furthermore, .NET 6 has one year left (EOL in Nov 2026 for an LTS), but many will choose to jump to .NET 10 soon instead of waiting that long. The new support policy (2-year STS) means .NET 9 is supported until late 2026, giving a bit more overlap. Nonetheless, companies are making plans: we expect a wave of .NET 10 adoption in 2026. [manorrock.com]
Community Initiatives: In the community, November/December will bring recaps and best-of-year content. Also, the .NET Foundation will hold board elections (they happen annually, often around this time) which could shape the direction of community projects. And not to forget, Christmas is coming â which means Advent of Code! Many .NET devs participate in the Advent of Code challenges in December, and itâs likely .NET 10âs improved performance or new features (like improved LINQ or span) will get unofficial âfield testingâ in those algorithmic puzzles.
Looking at the big picture, October set the stage for a transformative end-of-year for .NET. November 2025 is poised to be one of the most significant months in .NETâs recent history, with a major new runtime, a new VS, and the deep integration of AI into our tools. By the time you read the next Pulse (covering Novemberâs news), .NET 10 will be here and weâll be exploring its impact. Exciting times ahead â see you next month, when weâll digest all the announcements and what they mean for .NET developers moving forward!