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 September 2025 edition of Pulse on .NET, where we track the latest releases, innovations, and trends across the .NET ecosystem. This month brought the first release candidate of .NET 10 (the next LTS) with go-live support, important changes to .NET’s support policy, new AI-powered tooling in Visual Studio, and plenty of community-driven content. In this post, we’ll cover updates to the .NET runtime (including RC milestones and servicing releases), enhancements in developer tooling (from Visual Studio 2026 previews to GitHub Copilot integration), migration and modernization news for legacy apps, highlights from the community (interesting blogs, open-source projects, and events), and broader ecosystem developments (NuGet, MAUI, Azure, and beyond). To start, here’s a quick summary of September 2025’s key .NET updates and their release dates:
| Update | Release Date | Highlights | Source |
|---|---|---|---|
| .NET 10 RC1 (Release Candidate 1) | September 9, 2025 | First .NET 10 release candidate (go-live license); focus on final polish – includes Blazor persistent state, Identity metrics, MAUI CoreCLR preview, EF Core vector queries11. | .NET Blog (The .NET Team) |
| .NET 8.0.20 & 9.0.9 (Servicing) | September 9, 2025 | Routine Patch Tuesday updates for .NET 8 LTS and .NET 9 STS with non-security reliability fixes2 (no new features; .NET Framework 4.8.1 received only minor fixes). | .NET Blog (T. Overfield) |
| .NET Support Policy Update | September 16, 2025 | Microsoft extended Standard Term Support (STS) releases from 18 months to 24 months33. .NET 9’s support now runs until Nov 2026, aligning with .NET 8’s LTS timeline. | .NET Blog (J. Damkewala) |
| Visual Studio 2026 (Insiders) & VS 2022 17.14 | Sept 9 & Sept 30, 2025 | VS 2026 Insiders preview launched with major AI integration and performance boosts. Meanwhile, VS 2022 v17.14 (Sept update) back-ported “Agentic AI” features: AI Profiler Agent, Copilot-powered modernization tool, Mermaid diagram support, smarter code reviews44. | Visual Studio Blog (S. Liao) |
| Microsoft ‘Agent Framework’ (Preview) | September 30, 2025 | New open-source SDK to build and orchestrate AI agents in .NET, unifying Semantic Kernel & AutoGen with familiar .NET patterns5. Simplifies multi-agent workflows with a go-live preview on both .NET and Python. | .NET Blog (L. Quintanilla) |
.NET 8 & .NET 9 Servicing Updates: Microsoft issued its regular Patch Tuesday updates for .NET in early September. On September 9, 2025, .NET 8.0.20 (LTS) and .NET 9.0.9 (STS) were released, delivering the latest security and quality patches2. These updates contained non-security fixes and reliability improvements and introduced no new features. As expected, there were no breaking changes. All users on .NET 8 or .NET 9 are encouraged to upgrade to these versions to benefit from the fixes2. (Notably, .NET Framework had no security patches this month; a cumulative preview update for .NET Framework 4.8.1 came later with only minor fixes.) Routine servicing like this keeps the supported .NET versions stable and secure without changing developers’ APIs or behaviors.
.NET 10 Release Candidate 1: The big milestone of the month was the arrival of .NET 10 RC1 on September 9. This is the first of two planned release candidates for .NET 10 (which is slated for general availability in November 2025)1. RC1 comes with a “go-live” license, meaning it’s considered production-ready for early adopters, and it signals that .NET 10 is nearly complete. According to the .NET team, this RC is focused mostly on quality improvements and final refinements, with few new features compared to earlier previews66. Still, a couple of last-minute additions and noteworthy changes made it in:
ASP.NET Core & Blazor: RC1 introduced support for persistent component state in Blazor. This allows Blazor components to retain state across “enhanced navigation” events (like prerendering and interactivity transitions), improving performance and preserving user progress in web apps11. Developers can opt-in via a [PersistentState] attribute to control how state is stored and restored (with options to skip restoring on first render, etc.). Additionally, ASP.NET Core Identity in .NET 10 now emits a rich set of built-in metrics (counters and timings for user sign-ins, token generation, etc.) using Microsoft.AspNetCore.Identity diagnostics1. This telemetry helps monitor authentication performance in production. Other polish in ASP.NET Core includes validation improvements – e.g. new attributes to skip or scope model validation and better alignment with JSON serialization (properties marked [JsonIgnore] are now ignored by validation automatically)11. The team also refined OpenAPI support to fully embrace OpenAPI 3.1: nullable complex types are represented with oneOf schemas and various schema generation tweaks increase compatibility11. These improvements (some contributed by the community) make minimal APIs and generated API docs even more robust.
.NET MAUI: The cross-platform UI stack got some important updates in the RC. Diagnostics instrumentation was added across layout methods – meaning when you measure or arrange a MAUI UI element, the framework now emits trace events and metrics, making performance profiling easier11. The HybridWebView control (which hosts web content in-app) gained new events to let developers hook into its lifecycle1, and the RefreshView control picked up an IsRefreshEnabled property for consistency across platforms1. Perhaps most interesting, for Android development, .NET 10 RC1 includes experimental CoreCLR runtime support on Android1. Historically, Xamarin and MAUI apps on Android run on the Mono runtime; with this preview feature, developers can try running on CoreCLR (the same runtime used on Windows and servers). This may improve performance and unify behavior, though Microsoft cautions it’s not yet for production use and might produce larger binaries1. It’s a glimpse of potential future convergence of .NET runtimes across platforms.
Windows Desktop (WinForms/WPF): For WinForms developers, RC1 marks the full integration of Dark Mode support. In .NET 10, Windows Forms controls can natively respond to dark mode OS settings without needing experimental flags1. A new ControlStyles.ApplyThemingImplicitly flag was introduced to manage how theming is applied to controls, and several previously experimental async APIs (like Form.ShowAsync) are now stable with performance improvements1. WPF, on the other hand, had no new features in RC1 (the focus there is also on stability)6.
Libraries and EF Core: The core libraries in .NET 10 are essentially feature-complete at RC1. One highlight is in cryptography: RC1 confirms the new ML-DSA algorithm support and that Microsoft’s post-quantum encryption APIs are “API complete” as planned6 (indicating no further changes to those APIs before release). The much-anticipated UTF-8 string improvements also appear to be finalized (with new ToHexString/parse helpers, etc.). Entity Framework Core 10 in RC1 lit up a couple of big features: EF Core now has first-class support for SQL Server’s new vector data type and the VECTOR_DISTANCE() function, enabling semantic search queries (think AI embeddings) directly in SQL1. This goes hand-in-hand with a JSON columns feature – EF can map .NET types to JSON columns in relational databases, including updating nested object data without raw SQL1. For Azure Cosmos DB users, EF Core 10 adds full-text search and hybrid search capabilities, combining keyword and vector search for more powerful queries1. These data features reflect the growing importance of AI and search in modern apps. EF Core RC1 also improved support for complex/value types and introduced parameterized collection padding to optimize how it generates SQL for large IN clauses1.
Under the hood, .NET 10 RC1 is mostly about bug fixes, tuning, and final convergences of API behavior. The runtime, SDK, C# compiler, and F# compiler had no new feature additions – they’re essentially locked in, barring critical changes6. Performance work is ongoing, but from now until the final release the team will be focused on finishing touches and documentation. Given that .NET 10 will be an LTS (Long Term Support) version, many enterprises are evaluating these release candidates to plan migrations from older versions.
Standard Term Support (STS) now 24 Months: In a significant policy change, Microsoft announced in mid-September that odd-year .NET releases (STS releases) will be supported for 24 months instead of the previous 18 months33. This change is effective retroactively to .NET 9. In practical terms, it means .NET 9’s end-of-support date moved from May 2026 out to November 10, 202633— the same date that .NET 8 (the prior LTS) goes out of support. Going forward, every STS will be supported for one year after its successor release, aligning each STS’s lifespan with the next LTS’s first year. Why the change? Microsoft observed that some customers avoided STS versions due to the short support window, especially when using out-of-band components that might require a newer runtime (the classic example: libraries like .NET Aspire or Extensions packages that ship more frequently and might depend on an STS runtime)33. With 24-month support, adopting an STS release is less risky, and integrating those fast-evolving components won’t accidentally put you on a ticking clock. In short, even-numbered (LTS) releases still get 3 years of support, and now odd-numbered (STS) releases get 2 years33. This policy tweak was widely welcomed by the community – it provides more flexibility and a bigger window for those who want to ride the wave of annual releases without jumping immediately to the next version. Of course, .NET 10 being LTS is expected to see broad adoption, but the news means .NET 11 (in 2026) will be supported until late 2028 instead of mid-2028, and so on. Microsoft’s message remains: you can choose LTS for stability or STS for newest features, and now that choice is a bit easier to make.
Looking ahead, .NET 10 is on track: with RC1 out, we anticipate RC2 in a few weeks (early October) and then the final 10.0.0 GA in November (likely alongside the .NET Conf 2025 event). If you’re on .NET 8, you have a year from .NET 10’s release until its end-of-life – plenty of time, but it’s wise to start evaluating .NET 10 now because of its many improvements (C# 14, performance, new APIs). We’ll cover RC2 and final release details in upcoming editions.
Visual Studio 2026 Insiders Preview: .NET development often goes hand-in-hand with Visual Studio, and September marked a major step forward for Microsoft’s flagship IDE. At the Visual Studio Live! conference in early September, Microsoft unveiled Visual Studio 2026 (Insiders build) – essentially the first public preview of the next Visual Studio version. This release is branded as “Insiders,” indicating an early look at features that will form VS2026. The focus? Performance and deeply integrated AI assistance. The Visual Studio team promises that in VS 2026 “the loops you run most – opening solutions, navigating code, building, and pressing F5 – tighten up”, meaning large solutions load faster and overall IDE responsiveness is improved. Under the hood, VS 2026 includes a modernized UI (built on updated Windows UI frameworks) and lots of optimization.
But the headline features are all the new GitHub Copilot-powered AI integrations baked into the IDE. In VS 2026 Insiders, Copilot is not just a code completion tool – it’s present throughout the development workflow:
“Adaptive Paste”: an AI-powered paste operation where Copilot can adjust pasted code to fit your context. If you copy some code snippet, when you paste in VS2026, Copilot can automatically fix up formatting, minor errors, or even translate between languages if needed. This means less fiddling after copy-pasting sample code.
Contextual chat and commands: You can now right-click on code and trigger Copilot actions like “explain this code”, “optimize this method”, or “generate comments”. Essentially, Copilot’s natural language understanding is woven into context menus, so developers don’t have to prompt it from scratch – the IDE knows what you’re trying to do.
“Did You Mean?” search: The solution search (Ctrl+Q or the search box) is enhanced by AI to handle typos or fuzzy queries, suggesting likely matches even if your search text is slightly off. This addresses the common scenario of searching code or settings with imperfect keywords.
AI Profiler Agent: A brand-new Profiler Agent is introduced, which is an AI-driven performance diagnostic tool. You can ask in the Copilot Chat “@profiler why is my app slow?” and it will analyze CPU/memory usage, pinpoint bottlenecks, and even suggest fixes44. This is like having a performance expert on call – it automates what you’d normally do with PerfView or the VS Profiler, by interpreting the data and giving actionable advice. In VS 2026, the Profiler Agent can even generate BenchmarkDotNet benchmarks or instrumented code to validate that a suggested fix actually improved things44. This was hinted at in prior previews, but VS2026 makes it a native feature.
Bring Your Own Model: For companies or developers who have custom AI models, VS 2026’s Copilot Chat will allow plugging in other model backends (OpenAI, Anthropic, etc.) instead of the default Copilot model. This “BYOM” feature caters to enterprise scenarios where data compliance or custom training is required.
All these features show that VS 2026 is doubling down on what Microsoft calls “Agentic AI” – treating the IDE as a smart agent that can handle higher-level tasks, not just single-line completions. It’s worth noting that VS 2026 Insiders supports .NET 10 development out-of-the-box (the .NET 10 RC1 announcement explicitly mentioned using VS 2026 Insiders for the best experience66). The Insiders build is a separate install developers can try alongside VS 2022. Feedback is ongoing, and Microsoft even teased more to come (like an “Agent Mode” that could chain these AI actions together autonomously, which now seems closer to reality).
Visual Studio 2022 September Update (17.14): While the future is exciting with VS 2026, Microsoft didn’t leave current users behind – many AI features were backported to the stable Visual Studio 2022 in its September 2025 update. VS 2022 v17.14, released at the end of September, brings a “fully integrated and game-changing agentic AI experience” to the current IDE4. Essentially, some previews from VS 2026 have been graduated to VS 2022 for broader use:
The Profiler Agent described above is now available in VS 2022 as well4. Developers can invoke it through Copilot Chat (using “@profiler” prompts) to analyze performance of their apps without leaving VS. This indicates the feature matured enough to ship to all users.
The GitHub Copilot App Modernization tool is now directly integrated into VS 2022 as an @modernize agent4. This is the AI-assisted upgrade utility we discussed in last month’s edition (it was in public preview via a VS extension). Now, in VS 17.14, you can right-click a project and choose “Modernize”, or ask Copilot Chat to upgrade your project, and the tool will kick off inside the IDE44. It helps automate migrating a .NET Framework or older .NET Core app to the latest .NET and even suggests moving platform-specific stuff to Azure. Bringing it into the main product suggests it’s working well. If your enterprise is planning a big upgrade, this agent could save you a ton of time by handling the mechanics of project file changes and pointing out code that needs updating (e.g., adding Async APIs, swapping legacy crypto with modern APIs, etc., often with code fixes suggested automatically).
Copilot “Agent Mode” improvements: VS 2022’s Copilot Chat had an experimental “Agent” toggle for multi-step tasks. The September update brings speed and reliability improvements to it44. For example, progress indicators are clearer so you know the AI is working through a request, and caching enhancements make responses faster4. There’s also a new behind-the-scenes planning ability: the AI can break complex prompts into sub-tasks and solve them iteratively, using a scratchpad markdown file that updates live4. Early internal benchmarks show this helps with multi-step coding tasks. These upgrades make Copilot more robust in handling big asks (like “create a data access layer for these entities and wire it up to an API”).
MCP and advanced prompt tools: The September release references something called the Model Context Protocol (MCP) – this is essentially an interface for Copilot to use structured prompts, resources, and internal tool invocations44. For developers, it surfaces as a “+ Reference” dialog in Copilot Chat where you can insert predefined system prompts (like “review code for XYZ”) or attach relevant resources (like a specific file or an API schema as context)4. It’s a power-user feature, but it means you can supply Copilot with more context easily, improving its answers. Visual Studio is clearly evolving into a platform where AI can use external knowledge (docs, code context, etc.) more effectively through this MCP system.
Mermaid Diagram Generation: A fun and useful addition – VS 2022 now supports Mermaid diagrams in Markdown and even lets Copilot generate them4. Mermaid is a text-based diagramming tool. Now you can write Mermaid syntax in a .md file in VS and preview the diagram directly. Moreover, you can ask Copilot to “Create a sequence diagram for the API call flow”, for instance, and it will produce the Mermaid markup for you4. This lowers the barrier to quickly visualizing architecture or flows during development. Instead of manually drawing a flowchart, just describe what you need and get an editable diagram in seconds.
AI-Assisted Code Reviews: Local Git code reviews in VS got an AI boost as well. The GitHub Copilot code review features (which were previewing) are now integrated, meaning when you check your changes in Git Changes window, you can click a sparkle ✨ icon to have Copilot write a review of your pending commit44. It will leave comments on diffs as if it were a human reviewer, pointing out potential issues or improvements. Impressively, this uses the same models and approach as the cloud GitHub code reviews, but right inside VS. They’ve even added support for custom instructions: you can place a .copilot-instructions.md in your repo to tell the AI reviewer your project’s conventions or specific things to watch for4. The result is more tailored, useful feedback in code reviews4. While not a replacement for a teammate’s review, it’s like having a tireless junior reviewer ensuring you didn’t miss anything obvious.
In summary, Visual Studio’s tooling in September 2025 is heavily focused on AI assistance – from performance profiling to upgrading projects to generating diagrams and review comments. It feels like the development environment is becoming significantly more intelligent. For developers who have access to GitHub Copilot, these features can boost productivity and catch issues early. It’s also notable that JetBrains quickly responded to these changes: the makers of ReSharper and Rider (popular alternative .NET IDEs) announced day-one support for VS 2026 Insiders. JetBrains blogged about a ReSharper migration assistant that will automatically carry over your extensions and settings when moving to VS 2026, and highlighted that their latest ReSharper 2025.3 EAP is already compatible with VS Insiders and benefits from out-of-process performance improvements7. So, whether you use Visual Studio or third-party tools, the ecosystem is getting ready for this new AI-infused era of development.
Modernizing older .NET applications (legacy .NET Framework or early .NET Core versions) continues to be a major theme, and the tooling we mentioned above is a big part of that story. In September, the GitHub Copilot Modernization tool moved from a standalone preview into Visual Studio proper. Now simply invoking the @modernize agent in VS 2022 will guide you through upgrading your app to the latest .NET and even migrating it to cloud services4. For example, it can detect a local file system usage and suggest migrating it to Azure Blob Storage, or find a usage of Windows Identity and help switch it to Azure AD (Entra ID) and Managed Identity for secrets88 (these were scenarios earlier outlined in the GitHub preview). Having this in the IDE shortens the gap between reading upgrade documentation and actually doing it – the AI offers interactive, step-by-step changes.
Additionally, Microsoft’s .NET Upgrade Assistant (the rule-based upgrade tool) keeps improving, often in tandem. In fact, one can use Upgrade Assistant for the initial project file conversion and then Copilot for the tricky parts – a “best of both worlds” approach noted in recent guides88. No major new releases of Upgrade Assistant occurred this month, but the conceptual integration with AI is clearly paying off. Some developers shared stories that even large enterprise apps can be upgraded “with minimal manual changes” now8 – anecdotally, a team moving a .NET 6 app to .NET 9 said the tools handled the bulk of it automatically8. That’s encouraging for those still on aging Web Forms or WCF services – you have more help than ever to modernize.
It’s also worth highlighting Microsoft’s messaging around timing: With .NET 10 approaching, their guidance is to start evaluating .NET 10 RCs in Q3/Q4 2025 so you can plan production upgrades in 2026 (especially if you’re coming from .NET 6 or .NET Framework)88. Since .NET 8 support ends in one year, many organizations are deciding whether to jump to .NET 10 soon after it ships. Given the extended STS support, even those on .NET 9 now have the option to wait a bit longer without falling out of support. But the overall advice remains: don’t wait too long to modernize. The benefits (performance, cross-platform, new language features) are significant, and both Microsoft and the community have laid out a clearer path than ever to get you there.
On that note, community content this month included some great deep-dives on modernization best practices. For example, the Argon Systems blog recapped insights from Microsoft Build 2025 on using Upgrade Assistant + Copilot together, showing how after the mechanical upgrades, Copilot can handle the “last mile” fixes like refactoring specific APIs88. And a post by Mobilize.Net outlined a .NET 8 to .NET 10 migration checklist (essentially encouraging testing on .NET 10 RCs now, identifying any breaking changes early)88. The consensus is that with the tools available by late 2025, there’s little reason to postpone moving off old frameworks. Even dreaded migrations like ASP.NET MVC to ASP.NET Core are being tackled piece by piece (with “dual-run” strategies and shim libraries to keep parts of an app running during incremental conversion)88. And now that AI can help rewrite config files or suggest cloud replacements, the process is less overwhelming.
In short: If you maintain legacy .NET code, the water’s warm – jump in! This month’s developments show the investment is ongoing to make upgrades smoother, whether via automated tools or AI-powered assistance. The .NET team’s motto could be “modernize now, with a little help from your AI friends.”
Beyond the official releases, the .NET ecosystem was buzzing in September with community contributions, library updates, and events. Here are some highlights across various areas:
Web & Mobile Development (.NET MAUI, Blazor): As .NET 10 nears completion, client-side developers are seeing the fruits of those improvements. The .NET MAUI team held their September community stand-up (and even did one live from Prague during a conference!) to discuss the latest progress. A key point of excitement is the introduction of a XAML Hotload and ahead-of-time XAML compilation in .NET 10 (which had been mentioned in previews). These features drastically reduce app startup times and catch UI errors at compile time – something the community has wanted as MAUI matures. Also, the .NET MAUI Community Toolkit maintainers previewed some upcoming toolkit widgets and fixes, ensuring that as MAUI core gets faster, the ecosystem of community controls keeps up. On the web side, Blazor continued to gain traction, especially with the new persistent state and more robust auth patterns in RC1. A popular blog series by Andrew Lock titled “Exploring the .NET 10 preview” reached Part 6 and 7, with Part 6 focusing on passkey authentication in ASP.NET Core Identity9 – essentially how the WebAuthn improvements in .NET 10 enable passwordless login via passkeys (which is a big deal for modern web apps). Part 7 of his series (published around the end of September) dived into packaging .NET tools with Native AOT9, illustrating how .NET 10 lets you create faster, self-contained command-line tools. These posts from community experts help developers digest the sometimes esoteric new features and apply them in real projects.
NuGet & Package Ecosystem: Managing dependencies securely and easily is an evergreen topic. In mid-September, NuGet.org’s “Trusted Publishing” feature went live (after being announced previously). This is a more secure way to publish NuGet packages from CI/CD pipelines using short-lived tokens instead of long-lived API keys. It was highlighted by a Microsoft Learn article and quickly adopted by community maintainers. Andrew Lock wrote a guide “Publishing NuGet packages from GitHub Actions the easy way with Trusted Publishing”77 showing how to set it up. The gist: you link your GitHub repo to NuGet.org, and your build can get a one-time publish token via OIDC, eliminating the need to store a secret API key. This significantly reduces the risk of package supply chain attacks, a hot topic given the rise of software supply chain compromises. On a lighter note, some fun new libraries popped up on NuGet: one that made the rounds on social media was NaturalCron (introduced in August, but gaining more users now), which lets you schedule jobs with expressions like "every 2nd Tuesday at 3pm" instead of crontab format. It’s an example of making developers’ lives a bit easier with human-friendly abstractions. Another trending project was FlowSynx, an open-source framework for orchestrating declarative workflows in .NET (think data processing pipelines defined as code)7. FlowSynx was highlighted in early October, but essentially it’s a community-driven alternative to things like Durable Functions – showing how diverse the .NET open-source space is, tackling everything from CRON replacements to full workflow engines.
Cloud & Azure Integrations: .NET’s cloud story continues to evolve alongside Azure’s advancements. The Azure SDK team’s September 2025 update (official blog released in early October) emphasized security and identity changes – notably a heads-up that multi-factor authentication (MFA) will become mandatory for Azure Active Directory in the future, and the SDKs (including .NET Azure Identity library) are being prepared for that. In practice, this means .NET apps using Azure credentials may need to handle MFA requirements by 2026, and the libraries will provide new patterns to accommodate it. It’s a bit forward-looking but important for enterprise devs to note. Meanwhile, specific Azure services got some .NET love: for instance, Azure Functions announced that the old Linux Consumption Plan for serverless will be retired by 2028, pushing folks toward the newer “Flex” plan – relevant if you run .NET Functions on consumption plans. The Azure App Service team enabled easy swap to .NET 10 once it’s out, and Azure Container Apps now fully support .NET workloads with minimal boilerplate, as evidenced by demos of running containerized ASP.NET Core APIs easily. The synergy between .NET 10 and Azure’s container/cloud environment is strong – e.g. .NET 10’s smaller images and better threading goes hand-in-hand with Azure Kubernetes Service improvements. On the AI side, Azure AI Foundry’s GPT-5 preview (mentioned last month) continued to intrigue .NET devs. Some early adopters tried the Azure OpenAI .NET SDK with GPT-5 models, and while still in preview, it shows .NET can plug into cutting-edge AI with just a few NuGet packages. Expect more on this at Ignite in November.
Third-Party .NET Tools & Ecosystem: The .NET ecosystem isn’t just Microsoft. Developers rely on a range of third-party tools, and September saw activity here as well. JetBrains Rider, a popular cross-platform .NET IDE, released updates in lockstep with .NET 10 RC – ensuring their debugger and IntelliSense are fully up to date for C# 14 and .NET 10. JetBrains also addressed the performance issues in ReSharper (which historically could slow down Visual Studio). In a post aptly titled “Big change to ReSharper cuts Visual Studio freezes”, they detailed a six-year effort to rework ReSharper’s internals to be out-of-process and more async, reducing UI freezes significantly. This is great news for developers who use that extension for advanced refactorings and analysis – it shows that competition (maybe from Roslyn and Copilot) is driving improvements even in established tools. On another front, the F# community had something to cheer: an experimental project called Firefly was showcased, which is an F# compiler that can emit native code targeting CPU and even GPU directly. It’s very much a research/early-stage project (presented by Houston Haynes in a community meetup), but it demonstrates the innovation happening even in smaller .NET language communities. The idea of compiling F# to native code could open up new high-performance scenarios for F# (scientific computing, GPU tasks) without going through IL. While not mainstream yet, it underlines that .NET is more than C# – alternate languages and ideas are bubbling up, keeping the platform rich and diverse.
Community Content & Projects: As always, .NET developers worldwide shared knowledge through blogs, videos, and podcasts. We already mentioned Andrew Lock’s series and some other blog posts. A few more worth noting:
Events: On the events side, planning for the big upcoming conferences went into full swing. The .NET community is gearing up for .NET Conf 2025 – the annual free, virtual conference that will launch .NET 10. At the end of September, the .NET Foundation officially announced the dates (November 11–13, 2025) and opened registrations. They’re advertising it as a 15th anniversary celebration of .NET with the slogan “Learn what you can do with .NET 10.” Expect major keynote sessions on .NET 10, C# 14, and likely some surprise announcements. Meanwhile, Microsoft Ignite 2025 (a huge Microsoft conference spanning Azure, AI, and more) will be held November 18–21 in San Francisco. Ignite is more IT-pro focused but often has developer content too. Given the overlap with .NET 10’s release, we might see .NET represented in cloud and AI contexts at Ignite (perhaps showcasing the Agent Framework or large-scale Azure apps with .NET). Also, Visual Studio Live! Orlando 2025 is happening in November – where Microsoft’s Visual Studio team will present deep dives into VS 2026 and beyond. This was teased by the VS blog as “The Road to Visual Studio 2026” with a keynote from VS PM Mads Kristensen, promising to reveal more about performance gains and AI in the new IDE. For those who prefer in-person community events, smaller regional conferences started to return as well: e.g., .NET Assemble 2025 is scheduled in early October in the Netherlands, and local .NET User Groups have been hosting meetups focusing on .NET 10 RC features and migration stories.
In summary, the .NET ecosystem in September 2025 is vibrant and moving fast. We saw a stabilization of the core platform (as .NET 10 nears release), while at the same time an explosion of AI-assisted development tools that are changing how we write and upgrade code. The community is actively blogging, making videos, and releasing OSS libraries, ensuring that developers have plenty of learning material and extensions to play with. Whether you’re a web developer excited about Blazor enhancements, a cloud developer integrating .NET with Azure’s latest, or a desktop/mobile developer anticipating MAUI’s improvements – there was something new for you this month. The collective energy is building up toward the imminent launch of .NET 10, which promises to be a significant milestone.
As we wrap up the September 2025 Pulse, let’s take a peek at what’s on the horizon for .NET and beyond:
.NET 10 Release Candidate 2 and GA: The .NET team has indicated RC1 is the first of two RCs1, so expect .NET 10 RC2 to drop in early October. RC2 will likely be mostly fixes from RC1 feedback and final tweaks – basically what RC1 didn’t catch. By late October or early November, we’ll see .NET 10 reach General Availability (GA). The launch will coincide with the online .NET Conf 2025 (Nov 11–13). That event will have deep-dive sessions on all the new features, and the final release notes will enumerate everything that’s new since .NET 8. Because .NET 10 is LTS, it will quickly become the go-to version for many – including in Azure services and third-party clouds. We’ll cover the final release and early adoption stories in the next Pulse. Also watch for C# 14 to be officially released alongside .NET 10 – its new language features (like improved interceptors, shapes, etc., which were brewing in preview) will be fully documented and ready to use.
Tooling and IDE Updates: In the next couple of months, we’ll see Visual Studio 2022 v17.5 (or possibly 17.15, if they continue that numbering) and early previews of Visual Studio 2026 continuing to evolve. One anticipated feature is the Copilot “Agent Mode” GA – we might hear more at Microsoft Ignite (Nov 18–21), where devs from the VS team could show off how far the AI integration can go (perhaps an on-stage demo of VS automatically generating a simple app from a high-level prompt, for example). Also, for Mac users, there’s interest in what happens with Visual Studio for Mac (Microsoft had paused major development on it earlier). Any news on that might drop in a blog or at Ignite. And let’s keep an eye on JetBrains Rider 2025.3, which will likely release around the end of the year with full .NET 10 support and maybe more AI features (JetBrains hinted at integrating Amazon CodeWhisperer or their own AI into Rider).
Framework & Ecosystem Roadmap: Once .NET 10 ships, attention will turn to .NET 11 (2026) planning – but more immediately, there may be Entity Framework Core 8.1 or 10.1 updates. The EF team has been working on features like JSON column indexing and better bulk operations; some might land in a minor update next year. Also, library authors will start targeting .NET 10 – we’ll see updates of popular libs (Newtonsoft.Json, Serilog, etc.) tuned for .NET 10/C#14. On the ASP.NET Core side, after .NET 10’s release, we might get a minor ASP.NET Core 10.1 with small features or see previews of ASP.NET Core vNext that could bring things like integrated support for HTTP/3 features or more WASM improvements. Another thing to watch: .NET Aspire. This cloud-native framework had a big 9.4 release this summer; will there be an Aspire 10.0 aligned with .NET 10? Possibly – if so, it would likely be announced around or shortly after .NET 10 GA, bringing official support for running on .NET 10 and maybe new modules (since Aspire 9.4 introduced AI integration, perhaps 10.0 makes those features non-preview).
AI and “Agent” Tech: Microsoft’s preview of Agent Framework is just the beginning. Over the next months, they’ll gather feedback and likely iterate quickly (it’s open-source on GitHub, after all). By Build 2026 we could see a v1.0. For now, .NET developers interested in AI agents should try the preview and possibly see sessions about it at upcoming conferences (Ignite might have a breakout on building AI agents in .NET for enterprise workflows). Also, the retirement of the experimental AutoGen library (rolled into Agent Framework) means devs will concentrate on this new unified SDK. It’ll be interesting to see if community contributions appear – maybe someone will write a blog “Using Agent Framework to automate GitHub tasks” or similar, to showcase practical uses.
Community Events and Releases: October and November are packed: apart from .NET Conf and Ignite, there are regional events like JetBrains .NET Day Online, local user group meetups (expect a lot of “What’s new in .NET 10” talks worldwide), and perhaps an in-person MVP Summit (if Microsoft schedules one, those often happen in fall). We’ll also see F# Conf and other niche community conferences around this time. In the OSS world, keep an eye on projects like Akka.NET (a major update to 1.5 is in the works), Polly (resilience library, possibly releasing a new version aligning with .NET 10), and MonoGame (if any updates to support .NET 10 for game dev). The end of the year often brings maintenance releases (e.g., a .NET 8.0.21 in October with final patches, and .NET 8.0.22 in November which might be the last before .NET 10 takes over LTS).
All in all, as we move from preview to release, the .NET ecosystem is primed for a smooth transition to the new generation. It’s an exciting time to be a .NET developer – whether you’re eager to adopt the latest tech or carefully planning your upgrade path, there’s plenty of support and innovation to help you on your way. Stay tuned for next month’s edition of Pulse on .NET, where we’ll no doubt be celebrating the GA release of .NET 10 and diving into the early experiences of the community with it. Happy coding!