What is the .NET Desktop Runtime?
The .NET Desktop Runtime is a component of the .NET platform, Microsoft’s free, open-source, cross-platform framework for building and running applications. Specifically, it enables you to run existing Windows desktop applications built with .NET technologies like Windows Presentation Foundation (WPF), Windows Forms, or other desktop-focused workloads. It includes the core .NET Runtime but is optimized for desktop scenarios, handling execution of managed code without requiring the full .NET SDK (which is for development).
The .NET Desktop Runtime is a lightweight, open-source runtime environment that acts as an intermediary between your desktop application and the Windows operating system. It contains the essential components needed to execute applications that were developed using .NET frameworks, particularly those built with Windows Presentation Foundation (WPF) or Windows Forms technologies. Unlike the .NET Framework, which is an older Windows-only platform that comes pre-installed with Windows, the .NET Desktop Runtime represents a modern, more efficient alternative designed specifically for desktop application execution.
Unlike the ASP.NET Core Runtime (for web apps), the Desktop Runtime focuses on client-side desktop experiences. It’s lightweight and often installed automatically by apps that depend on it, but you can install it manually if needed.
Core Purpose and Role
- Enables Runtime Execution: It provides the necessary libraries and components (including the core .NET Runtime) for managed code to run on Windows. Applications compiled as “framework-dependent” rely on this being pre-installed on the target machine.
- Desktop-Specific Focus: Tailored for GUI-based client applications. It includes Windows desktop libraries beyond the base console/runtime capabilities, supporting user interactions, graphics, and Windows-specific features.
- Lightweight and Efficient: Unlike the older .NET Framework (pre-installed on Windows but heavier and Windows-only), the Desktop Runtime is modular, performant, and part of the cross-platform .NET ecosystem (formerly .NET Core).
- Deployment Models:
- Framework-Dependent: Smaller app size; requires the runtime installed.
- Self-Contained: Bundles the runtime with the app for easier distribution (larger footprint).
It acts as an intermediary between the application and the OS, handling Just-In-Time (JIT) compilation, garbage collection, security, and interop with native code.
Key Components and Architecture
- Includes the Base .NET Runtime: Handles core execution (CLR/CoreCLR equivalent), type system, assembly loading, etc. No need to install the plain .NET Runtime separately.
- Windows Desktop Libraries: Support for WinForms, WPF, and related APIs.
- Cross-Platform Foundations: Built on the unified .NET platform, allowing shared code with web/console apps, though desktop features remain Windows-centric (with some hybrid support via .NET MAUI).
- Performance Features: Modern versions (e.g., .NET 8/9) include Dynamic PGO (Profile-Guided Optimization), improved inlining, loop optimizations, and AOT (Ahead-of-Time) compilation options for faster startup and runtime performance.
Comparison with Related .NET Components
Use this table for clarity:
| Installer | Includes .NET Runtime | Includes .NET Desktop Runtime | Includes ASP.NET Core Runtime | Best For |
|---|---|---|---|---|
| .NET Runtime | Yes | No | No | Console apps, services |
| .NET Desktop Runtime | Yes | Yes | No | Windows desktop (WinForms/WPF) |
| ASP.NET Core Runtime | No | No | Yes | Web/server apps |
| .NET SDK | Yes | Yes | Yes | Development (compiling, tools) |
- Vs. .NET Framework (Legacy): .NET Framework (up to 4.8) is a separate, older Windows-only stack. Apps targeting it do not run on the .NET Desktop Runtime (and vice versa). They can coexist. The modern runtime is lighter and the recommended path for new development.
- Vs. Plain .NET Runtime: The Desktop variant adds GUI/desktop libraries; the plain one suffices for console apps.
- Vs. SDK: The SDK is for developers (includes compilers, CLI tools, etc.). Runtime is for running apps only.
- Side-by-Side Installation: Multiple versions (e.g., 6.0, 8.0, 9.0) install independently. An app targets a specific version.
Latest Version
As of November, 2025, the latest version is .NET 10.0 (release date: November 11, 2025). This is a Long Term Support (LTS) release, with support until November 2028. Previous versions like .NET 9.0 (Standard Term Support, ends November 2026) and .NET 8.0 LTS (ends November 2026) are still available for compatibility.
How to Download and Install on Windows
- Visit the Official Download Page: Go to dotnet.microsoft.com/download/dotnet.
- Select the Version: Choose .NET 10.0 from the list of versions.
- Choose the Runtime: Under “.NET 10.0”, select Desktop Runtime (not SDK or ASP.NET Core Runtime).
- Pick the Installer:
- x64 (recommended for most modern PCs): Download the .exe or .msi file (e.g., windowsdesktop-runtime-10.0.0-win-x64.exe).
- x86 (for 32-bit apps): Available if needed for legacy compatibility.
- Install:
- Run the downloaded file as Administrator.
- Follow the setup wizard (it’s straightforward, with options for per-machine or per-user install).
- Restart your PC if prompted.
- Verify installation: Open Command Prompt and run dotnet –list-runtimes to see installed runtimes.
Downloads are free, and the installer is about 50-70 MB. It’s supported on Windows 10 (version 1607+), Windows 11, and Windows Server 2016+.
Installation and System Requirements
The .NET Desktop Runtime needs to be installed on a Windows machine before running applications that depend on it. Windows does not include .NET Core versions (5, 6, 7, 8, and later) by default, though it does include older .NET Framework versions. When installing an application that requires a specific .NET Desktop Runtime version, the installer will typically check for the required version and prompt you to install it if necessary.
Common Use Cases and Troubleshooting
- Why Install It? Apps like certain games, tools (e.g., AutoCAD), or custom software may require it to launch.
- Multiple Versions? You can install side-by-side; .NET apps target specific versions.
- Issues? If an app complains about missing runtime, ensure the correct architecture (x64/x86) matches. For errors, check Event Viewer or Microsoft’s docs.
Overview of .NET Desktop Runtime Uses
The .NET Desktop Runtime is a key component of the .NET ecosystem, specifically designed to execute and support desktop applications on Windows (and to a limited extent, cross-platform via .NET MAUI for hybrid scenarios). It provides the underlying infrastructure for running managed code in desktop environments, ensuring high performance, security, and compatibility without needing the full .NET SDK (which is developer-focused). Unlike the ASP.NET Core Runtime (for web/server apps) or the general .NET Runtime (for console/microservices), the Desktop Runtime is tailored for graphical user interfaces (GUIs), user interactions, and client-side workloads.
In essence, its primary role is to act as a “host” for .NET-based desktop apps. When an application is deployed as framework-dependent, it relies on the Desktop Runtime being pre-installed on the target machine. Alternatively, apps can be self-contained, bundling the runtime with the app for easier distribution (though this increases file size). This makes it indispensable for end-users running third-party software and for developers targeting Windows desktop experiences.
Below, I’ll break down its uses in detail, including supported technologies, deployment scenarios, real-world applications, and benefits.
1. Core Functionality: Running and Hosting Desktop Applications
- Execution of Managed Code: The runtime compiles and executes C#, F#, or Visual Basic .NET code into intermediate language (IL), then just-in-time (JIT) compiles it to native machine code. This enables apps to leverage .NET’s garbage collection, exception handling, and threading models for robust, memory-efficient desktop programs.
- GUI Rendering and User Interaction: It handles rendering windows, controls, events (e.g., mouse clicks, keyboard input), and data binding, making it the backbone for interactive desktop software.
- Integration with Windows APIs: Deep integration with Win32 APIs allows access to system features like file dialogs, notifications, and hardware (e.g., printers, cameras via Media Foundation).
- Use Case Example: Launching legacy or modern Windows apps that crash without it, such as enterprise tools requiring .NET 8.0 or later.
2. Supported Technologies and Frameworks
The Desktop Runtime powers several UI frameworks, allowing developers to build rich, responsive interfaces. Here’s a comparison:
| Technology | Description | Primary Uses | .NET Version Support |
|---|---|---|---|
| Windows Presentation Foundation (WPF) | Vector-based UI framework using XAML for declarative markup; excels in data-driven UIs with animations and styling. | Enterprise dashboards, data visualization tools, media players. | .NET Framework 4.x+; .NET 5+ (modernized). |
| Windows Forms (WinForms) | Drag-and-drop designer for rapid prototyping; uses GDI+ for rendering. | Simple CRUD apps, admin tools, legacy migrations. | .NET Framework 2.0+; .NET Core 3.0+ (cross-platform experimental). |
| .NET MAUI (Multi-platform App UI) | Cross-platform extension for desktop (Windows/macOS); shares code with mobile. | Hybrid apps like productivity tools that run on multiple OSes. | .NET 6+ (full support in .NET 8+). |
| WinUI 3 | Modern Windows-native controls; integrates with Fluent Design. | High-fidelity Windows 11 apps with Mica/Acrylic effects. | .NET 5+ (via Windows App SDK). |
- How It’s Used: Developers target these in Visual Studio, compile to DLLs/EXEs, and the runtime loads them at startup. For instance, WPF apps use the runtime’s DirectX integration for hardware-accelerated graphics.
3. Deployment and Distribution Scenarios
- Framework-Dependent Deployment (FDD): The app is small (~MBs), but requires the runtime installed. Ideal for internal enterprise apps where IT manages updates. Use: Distributing via MSI installers in corporate networks.
- Self-Contained Deployment (SCD): Bundles the runtime (~100-200 MB). No prerequisites; “click-and-run.” Use: Public-facing tools like games or utilities on download sites.
- Single-File Publishing: Combines app + runtime into one EXE for simplicity. Use: Reducing deployment friction for end-users.
- Trimming and ReadyToRun: Optimizes for size/speed by removing unused code. Use: Mobile-like desktop apps (e.g., .NET MAUI hybrids).
- Advanced: Side-by-side versioning allows multiple runtimes (e.g., .NET 8 and 10) to coexist, preventing conflicts in multi-app environments.
4. Real-World Applications and Examples
The .NET Desktop Runtime underpins a wide range of software, from consumer tools to enterprise solutions. Here are notable examples, drawn from developer communities and case studies:
- Productivity and Development Tools:
- Visual Studio IDE: Parts of Microsoft’s flagship IDE (e.g., the “Copy Website” dialog) rely on WinForms/WPF hosted by the runtime for UI elements. It’s used daily by millions of developers for code editing and debugging.
- Paint.NET: A popular image editor built with .NET, leveraging the runtime for its layer-based editing and plugins.
- Enterprise and Business Software:
- Microsoft Office Suite Components: Certain add-ins and tools (e.g., Excel custom UIs) use .NET for automation and data binding.
- SharePoint Client Tools: Desktop clients for document management, using WPF for rich previews.
- Inventory Management Systems: Custom POS/billing apps in retail, like those built with WinForms for quick transactions.
- Media and Gaming:
- Forza Horizon Series: Xbox/PC racing games use .NET for UI overlays and telemetry dashboards.
- Audio Management Apps: Tools similar to iTunes for library organization, built with WPF for playlist visualizations.
- Scientific and Specialized:
- Bio-Tech Analysis Software: Desktop apps for medical sample analysis in labs, using .NET for data processing and charts.
- Anti-Virus Clients: Endpoint security tools (e.g., from vendors like Symantec) with .NET GUIs for scans and reports.
- Other Notable Mentions: Reflector (decompiler tool), Gnome Do (app launcher on Mono, .NET-compatible), and BBC Good Food app (hybrid desktop/mobile for recipes). In 2025, with .NET 10’s enhancements (e.g., better AOT compilation), it’s increasingly used in AI-integrated desktops like local ML model trainers.
5. Benefits and Advanced Uses
- Performance and Scalability: JIT/AOT compilation ensures fast startups; supports async patterns for responsive UIs in data-heavy apps.
- Security: Built-in code access security and cryptography for safe file handling.
- Cross-Platform Evolution: While primarily Windows, .NET 8+ enables Linux/macOS via Avalonia or Uno Platform wrappers.
- Integration with Modern Tech: Pairs with Azure for cloud-sync, ML.NET for on-device AI, or Entity Framework for local databases.
- Developer Productivity: Hot reload, NuGet packages, and Visual Studio tooling speed up iteration.
- Challenges/Edge Cases: For very lightweight apps, alternatives like Electron exist, but .NET excels in native feel and low overhead.
Key Components and Architecture
The .NET Desktop Runtime operates around the Common Language Runtime (CLR), which is the core engine responsible for executing .NET programs. The CLR performs several critical functions that make the runtime possible:
Code Execution and JIT Compilation: The CLR takes compiled .NET code (stored as Intermediate Language or IL) and converts it into machine instructions through Just-In-Time (JIT) compilation. This means your application code is compiled to native machine code just before execution, ensuring optimal performance on your specific system.
Memory Management: The runtime includes an automatic garbage collector that manages memory allocation and deallocation. When you create objects in your application, the runtime allocates memory from the managed heap. The garbage collector periodically scans the heap to identify objects no longer in use and reclaims their memory, preventing memory leaks and optimizing resource utilization. The collector uses a sophisticated algorithm that marks used memory, discards unused blocks, and compacts the heap to maintain efficiency.
Type Safety and Security: The .NET Desktop Runtime enforces strict type safety through the Common Type System (CTS), preventing unsafe memory operations, incorrect method invocations, and type-casting errors. It also implements code validation and verification mechanisms to protect applications from malware and malicious code.
Exception Handling: The runtime manages exceptions gracefully, allowing applications to recover from errors and continue execution smoothly without crashing.
Multi-Language Support: The CLR enables multiple programming languages (C#, F#, VB.NET, and others) to work together seamlessly within the same runtime environment, as they all compile to the same intermediate language.
Supported Application Types
The .NET Desktop Runtime specifically supports Windows desktop applications built using modern .NET frameworks:
Windows Presentation Foundation (WPF): A sophisticated framework for building rich, visually advanced desktop applications with complex user interfaces.
Windows Forms: A simpler, more traditional framework for building standard Windows desktop applications.
The runtime is Windows-only, as both WPF and Windows Forms rely on Windows-specific technologies like DirectX. This means applications built for the .NET Desktop Runtime will only execute on Windows systems and cannot run on Linux or macOS.
Performance Enhancements
Modern versions of the .NET Desktop Runtime include significant performance optimizations. .NET 9 and later versions feature Dynamic Profile-Guided Optimization (PGO), a code generator that optimizes your code based on actual usage patterns, potentially enhancing application performance by up to 20%. The runtime also includes improved loop optimizations and inlining capabilities that reduce execution overhead and speed up repetitive operations.
Relationship to Other Runtimes
It’s important to understand that .NET Desktop Runtime is fundamentally different from .NET Framework. The older .NET Framework is a heavier, Windows-only platform that comes pre-installed with Windows, while the .NET Desktop Runtime is a lighter, more modern successor based on .NET Core. These two runtimes are not backward compatible with each other—applications compiled for .NET Framework will not run on the .NET Desktop Runtime, and vice versa. Both can coexist on the same system to support applications targeting different frameworks.
The .NET Desktop Runtime also differs from the basic .NET Runtime (used for console applications) and the ASP.NET Core Runtime (used for web applications). You must install the appropriate runtime for your application type.
Common Use Cases
Game Development: Many games and gaming tools require the .NET Desktop Runtime because they use .NET code, typically written in C#.
Enterprise Desktop Applications: Businesses use the runtime to distribute internal tools and enterprise applications without requiring the full development environment on end-user machines.
Third-Party Software: Commercial and open-source desktop applications rely on the .NET Desktop Runtime for distribution and execution on user computers.
Distribution Models
When deploying .NET desktop applications, developers can choose between two approaches:
Shared Runtime: Applications rely on a globally installed runtime located in the system’s Program Files directory. Users must have the required runtime version pre-installed, but this saves disk space if multiple applications use the same runtime.
Self-Contained: Applications include the entire .NET Desktop Runtime as part of their installation package, ensuring they work on any Windows system regardless of what runtimes are already installed. This approach increases the application’s file size but guarantees compatibility.
Security and Maintenance
The .NET Desktop Runtime receives regular security updates and patches from Microsoft. Applications relying on the runtime automatically benefit from these security improvements. The runtime also handles code validation, preventing execution of malicious or corrupted code.
In summary, the .NET Desktop Runtime democratizes building and running sophisticated desktop apps, powering everything from everyday tools to mission-critical systems. If you’re developing or troubleshooting a specific app, share more details for tailored advice!
Supported .NET Desktop Runtime Versions for Windows 10 x64
As of November 14, 2025, Windows 10 (all editions, including Home and Pro, version 1607 and later) supports installation of multiple .NET Desktop Runtime versions side-by-side. This allows running apps built for different .NET targets without conflicts. However:
- System Requirements:
- Windows 10 x64 (64-bit architecture).
- Minimum OS version: 10.0.14393 (November 2016 Update, aka 1607) for .NET 3.1 and later.
- No additional prerequisites beyond a standard Windows installation.
- Important Note: Windows 10 reached end-of-life (EOL) on October 14, 2025. .NET Desktop Runtimes can still be installed and run manually, but you won’t receive automatic security updates for the OS or .NET via Windows Update. Manual downloads from Microsoft are required for .NET patches.
- Installation Recommendation: Only install currently supported versions (8.0, 9.0, 10.0) for new apps or security. Older versions (e.g., 6.0 or below) may be needed for legacy apps but lack ongoing support and pose security risks. Use the official download page: dotnet.microsoft.com/download/dotnet. Select “Desktop Runtime” under your chosen version, then “x64” for Windows.
Supported Versions Table
Here’s a breakdown of installable .NET Desktop Runtime versions on Windows 10 x64, including release status, support end dates, and notes. All are available as x64 installers (~50-70 MB EXE/MSI).
| Version | Release Date | Support Type | End-of-Support Date | Installable on Win10 x64? | Notes |
|---|---|---|---|---|---|
| 10.0 | November 11, 2025 | LTS | November 14, 2028 | Yes (recommended) | Latest LTS; full support including security updates. Ideal for new apps. |
| 9.0 | November 12, 2024 | STS | May 12, 2026 | Yes (recommended) | Current STS; supports modern desktop features like improved WPF performance. |
| 8.0 | November 14, 2023 | LTS | November 10, 2026 | Yes (recommended) | Widely used LTS; excellent for enterprise/legacy migrations. |
| 7.0 | November 8, 2022 | STS | May 14, 2024 (EOL) | Yes (legacy only) | Out of support; install only if an app specifically requires it (e.g., old WinForms tools). No security updates. |
| 6.0 | November 8, 2021 | LTS | November 12, 2024 (EOL) | Yes (legacy only) | Past EOL; use for apps targeting .NET 6, but upgrade recommended. |
| 5.0 | November 10, 2020 | STS | May 10, 2022 (EOL) | Yes (legacy only) | Severely outdated; avoid unless critical. |
| 3.1 (Core) | December 3, 2019 | LTS | December 13, 2022 (EOL) | Yes (legacy only) | Oldest modern version; common in pre-.NET 5 apps. |
- LTS (Long Term Support): 3 years of support; preferred for production.
- STS (Standard Term Support): 18 months; for testing newer features.
- How to Check Installed Versions: Open Command Prompt and run dotnet –list-runtimes. Look for entries like “Microsoft.WindowsDesktop.App 8.0.x [path] (x64)”.
- Multiple Versions: .NET supports side-by-side installs (e.g., 8.0 x64 and 10.0 x64 coexist). Apps specify their target version via global.json or project files.
- x86 Compatibility: If running 32-bit legacy apps, install the x86 variant alongside x64, but x64 is standard for modern Windows 10.
Supported .NET Desktop Runtime Versions for Windows 11 x64
As of November , 2025, Windows 11 (all editions, version 21H2 and later) fully supports installation of multiple .NET Desktop Runtime versions side-by-side on x64 architecture. This enables running apps targeting different .NET versions without issues. Windows 11 provides optimal compatibility, including automatic updates via Microsoft Store or Windows Update, and no end-of-life (EOL) concerns—unlike Windows 10.
- System Requirements:
- Windows 11 x64 (64-bit).
- Minimum OS version: 10.0.22000 (21H2) for full .NET 6+ support, but all builds from launch work.
- No additional prerequisites; installers handle dependencies.
- Installation Recommendation: Install currently supported versions (8.0, 9.0, 10.0) for security and new apps. Older versions can be installed for legacy compatibility but receive no updates. Download from the official page: dotnet.microsoft.com/download/dotnet. Select “Desktop Runtime” > your version > “x64” for Windows (EXE/MSI installers, ~50-70 MB).
Supported Versions Table
Here’s a breakdown of installable .NET Desktop Runtime versions on Windows 11 x64. Focus is on active/support phases; legacy ones are included for completeness but not recommended.
| Version | Release Date | Support Type | End-of-Support Date | Installable on Win11 x64? | Notes |
|---|---|---|---|---|---|
| 10.0 | November 11, 2025 | LTS | November 14, 2028 | Yes (recommended) | Latest LTS; enhanced performance for WPF/WinForms; full Windows 11 integration (e.g., Snap Layouts). |
| 9.0 | November 12, 2024 | STS | November 10, 2026 | Yes (recommended) | Current STS; ideal for testing features like improved .NET MAUI desktop support. |
| 8.0 | November 14, 2023 | LTS | November 10, 2026 | Yes (recommended) | Mature LTS; broad adoption for enterprise desktop apps. |
| 7.0 | November 8, 2022 | STS | May 14, 2024 (EOL) | Yes (legacy only) | Out of support; install only for specific old apps; upgrade advised. |
| 6.0 | November 8, 2021 | LTS | November 12, 2024 (EOL) | Yes (legacy only) | Past EOL; security risks; use for .NET 6-targeted legacy tools. |
| 5.0 | November 10, 2020 | STS | May 10, 2022 (EOL) | Yes (legacy only) | Outdated; avoid unless critical. |
| 3.1 (Core) | December 3, 2019 | LTS | December 13, 2022 (EOL) | Yes (legacy only) | Oldest viable; common in early .NET Core migrations. |
- LTS (Long Term Support): 3 years of full updates; best for production.
- STS (Standard Term Support): 18 months; for feature exploration.
- How to Check Installed Versions: Open Command Prompt/PowerShell and run dotnet –list-runtimes. Entries will show like “Microsoft.WindowsDesktop.App 10.0.x [path] (x64)”.
- Multiple Versions: Fully supported side-by-side (e.g., run .NET 8 and 10 apps concurrently). Apps declare targets via project files.
- x86 Note: For rare 32-bit legacy apps, install x86 variants alongside x64.
.NET LTS vs. STS: An Overview
In the .NET ecosystem, Microsoft categorizes its major releases into two support tracks: Long Term Support (LTS) and Standard Term Support (STS). These tracks determine how long a version receives updates, security patches, and technical support after its general availability (GA) release. This policy applies to .NET Core, .NET 5+, and unified .NET platforms, following Microsoft’s Modern Lifecycle Policy. The goal is to balance stability for production environments (LTS) with access to cutting-edge features (STS).
All .NET releases occur annually in November, with even-numbered versions (e.g., .NET 8, 10) designated as LTS and odd-numbered ones (e.g., .NET 9) as STS. Both tracks require staying on the latest patch level for ongoing support—updates are cumulative and released monthly (typically on Patch Tuesday). After end-of-support (EOS), no further fixes or assistance are provided, and upgrading is strongly recommended.
Key Differences: Comparison Table
| Aspect | LTS (Long Term Support) | STS (Standard Term Support) |
|---|---|---|
| Support Duration | 3 years from GA release. | 2 years from GA release. |
| Release Cadence | Even-numbered major versions (e.g., 8, 10). | Odd-numbered major versions (e.g., 7, 9). |
| Target Scenarios | Production apps needing long-term stability, enterprise deployments, and minimal upgrades. | Testing new features, short-term projects, or environments that can upgrade frequently. |
| Update Focus | Full servicing (security + functional fixes) for the entire period; last 6 months: security only. | Same as LTS: full servicing initially, security-only in final 6 months. |
| Pros | Predictable, extended lifecycle reduces upgrade costs; ideal for legacy migrations. | Earlier access to innovations (e.g., performance tweaks, new APIs). |
| Cons | Lacks the absolute latest features until the next LTS. | Shorter window requires more frequent upgrades. |
Current Versions (as of November, 2025)
- LTS Versions:
- .NET 10 (released November 11, 2025; EOS: November 14, 2028) – Latest LTS, recommended for new projects.
- .NET 8 (released November 14, 2023; EOS: November 10, 2026) – Widely adopted for its maturity and broad compatibility.
- STS Versions:
- .NET 9 (released November 12, 2024; EOS: November 10, 2026) – Current STS, great for experimenting with enhancements like improved AOT compilation or AI integrations.
Older versions like .NET 7 (STS, EOS May 2024) and .NET 6 (LTS, EOS November 2024) are out of support and should be upgraded to avoid vulnerabilities.
Recommendations for Use
- Choose LTS if you’re building mission-critical apps (e.g., desktop tools with WPF/WinForms, enterprise dashboards) where downtime for upgrades is costly. It’s the “safe bet” for most users, as it aligns with typical business planning cycles.
- Choose STS for agile development, prototypes, or when you need features from the latest release (e.g., better cross-platform support in .NET MAUI). Plan to migrate to the next LTS within 18-24 months.
- General Advice: Always target the latest supported version in your projects. Use tools like dotnet –list-sdks and dotnet –list-runtimes to check your environment. For go-live (pre-GA) releases like release candidates, support is limited (e.g., 6 months max).
Servicing and Security Details
- Patch Updates: Both tracks get monthly cumulative updates via installers, NuGet, or package managers. These include bug fixes, reliability improvements, and security patches.
- Maintenance Phase: In the final 6 months before EOS, only high-impact security issues are addressed—no new features or non-security fixes.
- Post-EOS: Versions become unsupported; Microsoft advises uninstalling them (e.g., via Windows Settings > Apps) and migrating. Community support may exist, but no official help.
- How to Stay Updated: Enable automatic updates in Visual Studio or use the .NET CLI (dotnet workload update). Check the official .NET download page for the latest installers.