Mungomash LLC
.NET Versions

2002 – 2025

.NET Versions

Every public release of .NET — .NET Framework 1.0 in February 2002 through .NET 10 in November 2025 — with support windows, end-of-life dates, and the major changes per version. Plus the Mono lineage, the Connect(); 2014 open-source pivot, the Xamarin acquisition, and the .NET 5 unification.

Era & support

Era

Framework — .NET Framework 1.0 – 4.8.1, 2002–2022, Windows-only
Core — .NET Core 1.0 – 3.1, 2016–2019, the cross-platform pivot
Modern — .NET 5+, 2020 onward, the unified annual line

Support

LTS — Long-Term Support, 3 years (even integers: 6, 8, 10)
STS — Standard-Term Support, 18 months (odd integers: 5, 7, 9)
Maintained — security updates only, no new features (Framework 4.x)
EOL — past its support window; no further updates

.NET version table

Version
.NET 10
Modern
LTS
EOL Nov 2028
Nov 11, 2025
Latest LTS. Continued AOT and runtime work; C# 14; ASP.NET Core OpenAPI improvements.
  • Long-Term Support release with three years of patches through November 2028.
  • Continued performance and AOT work in the runtime; native AOT becomes a more practical default for ASP.NET Core deployments.
  • C# 14 language updates — primary-constructor refinements, partial properties, broader collection-expression conversions.
  • OpenAPI generation in ASP.NET Core continues to mature as the supported successor to Swashbuckle.
  • MAUI improvements, Blazor server / WebAssembly refinement.
  • Confirm latest point release against dotnet/core releases.md at build time.
Version
.NET 9
Modern
STS
EOL May 2026
Nov 12, 2024
STS. GC and AOT work; OpenAPI replaces Swashbuckle in ASP.NET Core; HybridCache; C# 13.
  • Standard-Term Support — 18 months of patches, EOL May 2026.
  • Garbage-collection improvements continued from the .NET 8 work.
  • OpenAPI generation built into ASP.NET Core, supplanting third-party Swashbuckle as the recommended path.
  • HybridCache — a unified L1/L2 caching primitive.
  • C# 13: params for any collection type, partial properties, lock-on-typed-statement.
Version
.NET 8
Modern
LTS
EOL Nov 2026
Nov 14, 2023
LTS. Native AOT for ASP.NET Core; TimeProvider; MAUI graduates; C# 12.
  • Native AOT for ASP.NET Core — web servers compile to a single native binary with sub-100ms cold-start. The release that made AOT a real production target.
  • TimeProvider abstraction — finally a sanctioned way to inject "the current time" for testable code.
  • IExceptionHandler middleware in ASP.NET Core.
  • .NET MAUI graduates to first-class citizen status; Visual Studio integration matures.
  • C# 12 — primary constructors on classes (not just records), collection expressions, default lambda parameters, alias any type.
  • Across-the-board performance work; Stephen Toub's annual Performance Improvements in .NET 8 post is the canonical summary.
Version
.NET 7
Modern
EOL
May 14, 2024
Nov 8, 2022
STS. Native AOT preview for console; generic math interfaces; rate limiting in ASP.NET Core; C# 11.
  • Standard-Term Support; reached EOL May 14, 2024.
  • Native AOT for some console workloads — the foundation for .NET 8's ASP.NET Core AOT support.
  • Generic math interfaces (INumber<T>, IFloatingPoint<T>) — polymorphic code that operates over any numeric type.
  • Rate-limiting middleware in ASP.NET Core.
  • C# 11 — raw string literals, list patterns, required members, generic attributes.
  • JSON contract customization; HTTP/3 support.
Version
.NET 6
Modern
EOL
Nov 12, 2024
Nov 8, 2021
First LTS of the unified era. MAUI preview; minimal APIs; hot reload; C# 10.
  • First LTS release of the unified post-Core era; reached EOL November 2024.
  • .NET MAUI preview — the iOS / Android / macOS / Windows successor to Xamarin Forms (graduated in .NET 7).
  • Minimal APIs in ASP.NET Core — HTTP endpoints with a fraction of the ceremony of MVC controllers.
  • Hot reload across dotnet watch and Visual Studio.
  • C# 10 — global usings, file-scoped namespaces, record structs, const string interpolation.
  • Source generators became mainstream (System.Text.Json, logging, regex).
Version
.NET 5
Modern
EOL
May 10, 2022
Nov 10, 2020
The unification. Skipped 4 to avoid confusion with Framework 4.x. C# 9 records.
  • Skipped .NET 4 — the version was deliberately bumped past 4 to avoid colliding with the .NET Framework 4.x name space.
  • The unification — one .NET. No more separate Framework / Core / Mono / Xamarin runtime stories. Single BCL target.
  • Single-file deployment — ship a self-contained app as one executable.
  • C# 9 — record types, init-only setters, top-level statements, target-typed new, pattern-matching enhancements.
  • Half-precision floats (System.Half); Windows ARM64 support.

The .NET 5 unification — November 2020. Above this line: the modern unified Modern era. Below: the Core era that ran 2016–2019 as the cross-platform rewrite. The version-number jump from 3.1 to 5 was deliberate (see the .NET 5 row) and the prose section on the unification.

Version
.NET Core 3.1
Core
EOL
Dec 13, 2022
Dec 3, 2019
LTS. Final release under the "Core" branding. ARM64 work matures.
  • Long-Term Support — the last release branded "Core" and the final pre-unification LTS.
  • Significant ARM64 work; broader Linux / macOS hardware coverage.
  • Smaller Docker images.
  • Last release before the 2020 unification under plain ".NET 5".
Version
.NET Core 3.0
Core
EOL
Mar 3, 2020
Sep 23, 2019
WPF and Windows Forms on .NET Core (Windows-only). gRPC. Blazor Server.
  • WPF and Windows Forms ported to .NET Core — Windows-only, but the moment Core became a credible target for desktop apps.
  • gRPC support built in.
  • Blazor Server — render a Razor component tree on the server, push DOM diffs over SignalR.
  • Default executables (./myapp) instead of always going through dotnet myapp.dll.
  • C# 8 — nullable reference types, async streams, default interface methods, switch expressions, indices and ranges.
Version
.NET Core 2.2
Core
EOL
Dec 23, 2019
Dec 4, 2018
Non-LTS. ASP.NET Core endpoint routing.
  • Non-LTS interim release.
  • ASP.NET Core endpoint routing — precursor to today's app.MapGet-style minimal APIs.
  • Health checks middleware.
  • Tiered compilation enabled by default.
Version
.NET Core 2.1
Core
EOL
Aug 21, 2021
May 30, 2018
First LTS in Core line. Span<T>; the start of the performance-work theme.
  • First LTS in the Core line.
  • Span<T> and Memory<T> — allocation-free slicing of contiguous memory. The primitive that unlocked the .NET-performance-rewrite era.
  • HttpClientFactory — the sanctioned answer to HttpClient lifetime woes.
  • dotnet CLI tooling matures; global tools introduced.
  • Significant Roslyn improvements.
Version
.NET Core 2.0
Core
EOL
Oct 1, 2018
Aug 14, 2017
.NET Standard 2.0 — the API spec that closed the gap with Framework.
  • .NET Standard 2.0 — the API surface specification that allowed library authors to target a common surface across .NET Framework 4.6.1+ and .NET Core 2.0.
  • BCL coverage roughly doubled, closing most of the gap with .NET Framework that 1.x had left open.
  • Visual Basic on .NET Core for the first time.
  • Razor Pages introduced as a lighter-weight alternative to MVC for page-centric web apps.
Version
.NET Core 1.1
Core
EOL
Jun 27, 2019
Nov 16, 2016
More BCL coverage; expanded Linux distro support.
  • Roughly 1,400 new APIs added to the BCL.
  • Expanded Linux distribution support.
  • Kestrel improvements and URL rewriting middleware in ASP.NET Core.
Version
.NET Core 1.0
Core
EOL
Jun 27, 2019
Jun 27, 2016
First cross-platform release. Linux, macOS, Windows. MIT-licensed from day one.
  • First cross-platform .NET — ran on Linux, macOS, and Windows. The deliverable of the strategic pivot announced at Connect(); 2014.
  • MIT-licensed from day one.
  • dotnet CLI — the new front door for build, run, publish, test.
  • Significantly smaller BCL than .NET Framework; many APIs would arrive in 2.0.
  • Shipped at Build 2016 alongside the public release of dotnet new.

The cross-platform pivot — June 2016. Above this line: the Core era — cross-platform, MIT-licensed, a from-scratch rewrite of the runtime, BCL, and tooling. Below: the Framework era — Windows-only, the original 2002 line that's still maintained but no longer evolving. The strategic announcement came at Connect(); 2014; the actual code shipped in mid-2016.

Version
.NET Framework 4.8.1
Framework
Maintained
security only
Aug 9, 2022
Last new Framework release. ARM64 support; accessibility improvements.
  • ARM64 support — the last new architecture for the Framework line.
  • Accessibility improvements across Windows Forms and WPF.
  • Microsoft has stated that no .NET Framework 4.9 is planned. New features go to modern .NET; Framework receives security updates as long as it ships with a supported Windows release.
  • Final-form Framework. Most new development should target modern .NET; Framework remains for legacy apps that can't migrate.
Version
.NET Framework 4.8
Framework
Maintained
security only
Apr 18, 2019
"We are not adding features here anymore." Last major Framework version.
  • The line where Microsoft formally communicated that the Framework would no longer receive new features — a clean break to redirect the developer community to .NET Core / modern .NET.
  • Reduced FIPS impact; high-DPI improvements in Windows Forms.
  • JIT improvements ported back from .NET Core's RyuJIT work.
  • Default for many enterprise apps that hadn't migrated to Core / modern .NET; still ships with all supported Windows releases.
Version
.NET Framework 4.7.2
Framework
Maintained
security only
Apr 30, 2018
ValueTuples and Span<T> supports brought back to Framework via .NET Standard 2.0.
  • Wider .NET Standard 2.0 surface available without third-party shims.
  • Improved high-DPI support and ASP.NET dependency-injection hooks.
  • Cryptography updates; ECDSA certificates.
Version
.NET Framework 4.7.1
Framework
Maintained
security only
Oct 17, 2017
.NET Standard 2.0 support; runtime and BCL improvements.
  • First Framework version with .NET Standard 2.0 support.
  • Garbage-collection improvements, especially around large-object-heap fragmentation.
  • Configuration builders.
Version
.NET Framework 4.7
Framework
Maintained
security only
Apr 5, 2017
High-DPI support in Windows Forms; TLS 1.2 default.
  • High-DPI support in Windows Forms after years of complaints.
  • TLS 1.2 became the default protocol negotiation.
  • Touch and stylus support improvements in WPF.
Version
.NET Framework 4.6.2
Framework
Maintained
security only
Aug 2, 2016
Long-path support; CNG certificates.
  • Long-path support (paths longer than MAX_PATH) on supported Windows.
  • CNG certificate support.
  • SQL Server Always Encrypted.
Version
.NET Framework 4.6.1
Framework
EOL
Apr 26, 2022
Nov 30, 2015
Profile improvements; broader TLS 1.2 support.
  • X509 certificate improvements; broader TLS 1.2 support.
  • Cryptography enhancements.
  • EOL April 2022 standalone; later only via Windows-bundled support.
Version
.NET Framework 4.6
Framework
EOL
Apr 26, 2022
Jul 20, 2015
RyuJIT (the new x64 JIT). Roslyn GA after the open-sourcing earlier in 2014.
  • RyuJIT — the new x64 JIT replacing the original .NET 1.0-era code generator.
  • The .NET Compiler Platform "Roslyn" went GA — the C# / VB compilers had been rewritten in C# itself and open-sourced in April 2014.
  • HTTP/2 support in ASP.NET.
  • Event Tracing for Windows (ETW) improvements.
Version
.NET Framework 4.5.2
Framework
EOL
Apr 26, 2022
May 5, 2014
Incremental update; ASP.NET background-task improvements.
  • Background scheduling improvements in ASP.NET (HostingEnvironment.QueueBackgroundWorkItem).
  • Higher DPI improvements in Windows Forms; framework-internal performance work.
Version
.NET Framework 4.5.1
Framework
EOL
Jan 12, 2016
Oct 17, 2013
Edit-and-continue for x64; incremental.
  • Edit-and-continue for x64 in Visual Studio.
  • Async-aware debugging across method boundaries.
  • Garbage-collection improvements.
Version
.NET Framework 4.5
Framework
EOL
Jan 12, 2016
Aug 15, 2012
async / await in C# 5 and VB 11. ASP.NET MVC 4, Web API.
  • async / await — C# 5 and VB 11 introduced the language-level async pattern that has shaped every C# codebase written since. The single largest .NET feature of the post-LINQ era.
  • ASP.NET MVC 4, Web API, SignalR; the foundation of the modern ASP.NET stack.
  • Last Framework version to drop Windows XP / Server 2003 support.
  • WPF improvements; new tasks-based async patterns across the BCL.
  • Significant garbage-collection and JIT improvements.
Version
.NET Framework 4.0
Framework
EOL
Jan 12, 2016
Apr 12, 2010
CLR 4.0 (the second and final new CLR). dynamic, Task Parallel Library.
  • CLR 4.0 — the second new CLR, after CLR 2.0 in 2005. CLR 4.0 was the last major CLR before the unified .NET 5 runtime in 2020.
  • dynamic keyword and the DLR (Dynamic Language Runtime).
  • Task Parallel Library — Task, Parallel.For, the data-parallelism primitives that async/await would later build on.
  • Side-by-side runtime versioning — multiple Framework versions on the same machine.
  • Code Contracts; PLINQ; Managed Extensibility Framework (MEF).
Version
.NET Framework 3.5
Framework
Maintained
Windows-bundled
Nov 19, 2007
LINQ. Lambda expressions, expression trees, extension methods, var.
  • LINQ (Language-Integrated Query) — query syntax, expression trees, lambda expressions, the var keyword, extension methods, anonymous types. The .NET release that defined late-2000s Microsoft developer experience.
  • Still ran on CLR 2.0 — the language and BCL improvements were layered on top of the existing runtime.
  • WCF, WF, and WPF improvements built on top of the 3.0 base.
  • Lifecycle is tied to each Windows release that bundled it — many supported Windows installs include it as an optional feature.
Version
.NET Framework 3.0
Framework
EOL
Jul 14, 2015
Nov 6, 2006
WPF, WCF, WF, CardSpace. Originally branded "WinFX". Still CLR 2.0.
  • Originally announced as WinFX; rebranded to ".NET Framework 3.0" before release.
  • WPF (codename Avalon) — XAML-driven UI framework; the basis of every Microsoft desktop UI built since.
  • WCF (codename Indigo) — unified communication framework: web services, named pipes, MSMQ.
  • Windows Workflow Foundation; CardSpace identity layer.
  • Still CLR 2.0 underneath — this was a BCL / framework expansion, not a runtime release.
Version
.NET Framework 2.0
Framework
EOL
Jul 14, 2015
Nov 7, 2005
CLR 2.0. Generics, anonymous methods, partial classes, nullable types.
  • CLR 2.0 — new runtime supporting generics natively, with type information preserved at runtime (unlike Java's erasure).
  • Generics, anonymous methods, partial classes, nullable types — the language and runtime release that turned C# into a serious enterprise language.
  • ASP.NET 2.0 master pages, themes, membership.
  • BCL expansions across the board.
  • Shipped alongside SQL Server 2005 and Visual Studio 2005.
Version
.NET Framework 1.1
Framework
EOL
Oct 8, 2013
Apr 24, 2003
Bundled with Windows Server 2003 — first OS-bundled .NET. ASP.NET Mobile; IPv6.
  • First .NET Framework version bundled with a Windows release (Windows Server 2003).
  • ASP.NET Mobile Controls; built-in IPv6 support.
  • ODBC and Oracle data providers in the box.
  • Side-by-side install with 1.0 supported.
Version
.NET Framework 1.0
Framework
EOL
Jul 14, 2009
Feb 13, 2002
First release. CLR 1.0; C# 1.0; Windows Forms; ASP.NET 1.0; ADO.NET.
  • The original .NET. CLR 1.0; C# 1.0 and VB.NET 7.0; Windows Forms; ASP.NET 1.0; ADO.NET.
  • Shipped with Visual Studio .NET 2002.
  • Anders Hejlsberg's first major language design at Microsoft after his earlier work on Turbo Pascal and Delphi at Borland (Hejlsberg moved to Microsoft in 1996).
  • Patrick Dussud was the lead architect on the CLR.
  • Originally proprietary, Windows-only. Microsoft would not open-source the platform until twelve years later.

Click any row to expand. Each row has a stable id for sharing — e.g. /data/dotnet/versions/#dotnet-8, #dotnet-core-2-1, #dotnet-framework-3-5. LTS / STS support windows for modern .NET are documented at dotnet.microsoft.com/platform/support/policy.

The original 2002 launch

.NET was previewed at Microsoft's Professional Developers Conference on July 11, 2000, and shipped February 13, 2002 with Visual Studio .NET. Microsoft's response to Java's positioning as a cross-platform, garbage-collected, JIT-compiled enterprise runtime — with carefully chosen differences (real generics with reified type information, value types, properties and events as first-class language constructs).

Anders Hejlsberg led the C# language design after his earlier work on Turbo Pascal and Delphi at Borland; Hejlsberg moved to Microsoft in 1996. Patrick Dussud was the lead architect on the CLR. Brad Abrams and Krzysztof Cwalina defined the BCL design conventions captured in Framework Design Guidelines. .NET 1.0 was proprietary, Windows-only, and shipped as a Windows component — a posture that would not change for twelve years.

C# vs. Java

.NET shipped explicitly as a competitor to Java, after Microsoft's relationship with Sun deteriorated through the J/Direct and J++ episode and the Sun v. Microsoft settlement that ended Microsoft's Java licensing in January 2001. Hejlsberg has been candid that early C# was Java-influenced with deliberate diversions: real generics with type information preserved at runtime (unlike Java's erasure), value types (struct), delegates and events as first-class language constructs, properties as syntactic sugar over getter/setter pairs, and the using statement for deterministic disposal. The two languages have evolved on parallel tracks since — with C# generally adding language features faster.

The Mono lineage

Mono was started in July 2001 by Miguel de Icaza at Ximian as an open-source reimplementation of the .NET CLR and BCL on Linux — before .NET 1.0 had even shipped. Ximian was acquired by Novell in 2003. After Novell was acquired by Attachmate in 2011, the Mono team founded Xamarin, which built iOS / Android / macOS toolchains on top of Mono.

Microsoft acquired Xamarin in February 2016 (reportedly $300–500M, never officially disclosed). Miguel de Icaza joined Microsoft as a Distinguished Engineer; the Mono runtime was relicensed under MIT shortly after. The Mono runtime continued to ship through .NET 7 inside the MAUI toolchain. In 2024 Microsoft formally handed Mono off to the Wine project as its long-term steward — closing a 23-year arc from outsider clone to supported derived runtime.

The 2007 LINQ revolution

.NET Framework 3.5 plus C# 3 plus VB 9 introduced LINQ (Language-Integrated Query) in November 2007, alongside a related set of language features — lambda expressions, extension methods, anonymous types, the var keyword, expression trees. LINQ turned C# from a Java alternative into a notably more expressive language and opened the door for query providers like LINQ to SQL and Entity Framework. The single largest leap in the C# language story until pattern matching and records arrived in C# 8–9.

The Roslyn rewrite (2010–2014)

Microsoft began rewriting the C# and VB compilers in C# itself — the "Roslyn" project, named after a Seattle suburb — starting around 2010. Roslyn was open-sourced under the Apache 2.0 license in April 2014 and shipped GA with Visual Studio 2015 and .NET Framework 4.6 in 2015. The compiler-as-a-service architecture made source generators, real-time analyzers, and the modern Visual Studio / VS Code experience possible, and quietly turned the C# compiler into one of the most-used pieces of open-source code in the world.

Connect(); 2014 — the open-source pivot

On November 12, 2014, Satya Nadella's still-new Microsoft (Nadella took over in February 2014) announced at the Connect(); 2014 event that .NET would be open-sourced under the MIT license, the .NET Foundation would be created to govern the project, ASP.NET vNext would become a new from-scratch cross-platform runtime (later renamed ASP.NET Core), and Visual Studio Community Edition would be free.

It was the largest single strategic reversal in Microsoft's developer-tools history. Twelve years of "we don't open-source platform code" became "we open-source all of it." Most of the post-2014 Microsoft developer story — TypeScript, VS Code, GitHub acquisition, Azure-first development, the modern .NET cadence — flows from this event.

The .NET Foundation

The .NET Foundation was founded April 3, 2014 to host the open-source projects. Independent legal entity with a board that includes both Microsoft and outside members. Hosts dotnet/runtime, dotnet/sdk, dotnet/aspnetcore, dotnet/maui, dotnet/roslyn, and dozens of community projects (NuGet, Newtonsoft.Json, Avalonia, ML.NET). Has had its share of governance debates over the years; remains the structural answer to "who owns the .NET ecosystem outside of Microsoft proper."

The Xamarin acquisition (February 2016)

Microsoft acquired Xamarin in February 2016 for an undisclosed sum (reported as $300–500M). Miguel de Icaza joined Microsoft as a Distinguished Engineer (a position he held until departing in 2022); Nat Friedman, the other Xamarin co-founder, would later become CEO of GitHub after Microsoft acquired GitHub in 2018. The Mono runtime and the Xamarin Studio iOS / Android / macOS toolchain were integrated into Visual Studio. Xamarin Forms eventually evolved into .NET MAUI in .NET 6 (2021).

The .NET Core pivot (2014–2020)

ASP.NET vNext — announced at Connect(); 2014 — was renamed ASP.NET Core, and the runtime under it became .NET Core. From-scratch rewrite of the runtime, BCL, and tooling around three goals: cross-platform support (Linux, macOS, Windows), open development on GitHub, and side-by-side installation on the same machine.

.NET Core 1.0 shipped at Build 2016 (June 27, 2016). 2.0 (August 2017) brought .NET Standard 2.0 and a much larger BCL. 2.1 (May 2018) was the first LTS in the line and shipped Span<T>, the primitive that unlocked the .NET-performance era. 3.0 (September 2019) ported WPF and Windows Forms to .NET Core (Windows-only). 3.1 (December 2019) was the final release under the "Core" branding.

The .NET 5 unification (November 2020)

.NET 5 shipped on November 10, 2020. One .NET, one BCL, no more Framework / Core / Mono / Xamarin runtime split. The version-number jump from 3.1 to 5 was deliberate: .NET 4 was skipped to avoid colliding with the long-running .NET Framework 4.x name space and the inevitable confusion around "is .NET 4 the same as Framework 4?"

From .NET 5 forward there is one runtime story across the targets that previously had separate runtimes (Windows desktop, ASP.NET Core, iOS / Android via Xamarin / MAUI, WebAssembly via Blazor). .NET Standard was deprecated as the cross-runtime API spec because the unified runtime made it unnecessary — existing libraries targeting netstandard2.0 still work, but new libraries should target a specific .NET version like net8.0.

The annual November cadence (2020–)

Since .NET 5, every November ships a new major version. Even-numbered releases (6, 8, 10) are LTS with three years of support. Odd-numbered releases (5, 7, 9) are STS with eighteen months of support. The cadence is documented at dotnet.microsoft.com/platform/support/policy and is the load-bearing piece of context for support-window decisions.

For a developer planning a multi-year project, the practical advice has been "target the LTS" since the cadence was formalized in 2021. The STS releases are useful for trying upcoming language features and for shorter-lived workloads that will be re-deployed before the 18-month support window ends; the LTS releases are the right default for production services.

The native-AOT story (2022–)

.NET 7 introduced native AOT (ahead-of-time) compilation for console and library workloads in November 2022. .NET 8 extended it to ASP.NET Core in November 2023, making it a real production target for cloud workloads. .NET 9 and 10 continued the work on size, startup time, and trim safety. The end goal: .NET binaries that compete with Go and Rust on cold-start time and deployment size for serverless and microservice workloads, while keeping the C# language and BCL developer experience.

.NET Standard — the parallel API spec

.NET Standard was a specification for the API surface that library authors could target to be portable across .NET Framework, .NET Core, Mono, Xamarin, and Unity, defined as a series of versions (1.0 through 2.1, 2016–2019). It was not itself a runtime — just an agreement that "if you target netstandard2.0, your library will work on any conforming runtime." For its era, it was an essential bridge.

The .NET 5 unification deprecated .NET Standard as the cross-runtime spec, because the unified runtime no longer needed it. Existing libraries targeting netstandard2.0 still work everywhere, including on modern .NET. New libraries should target a specific .NET version like net8.0 — or netstandard2.0 if they need to keep supporting .NET Framework consumers. Microsoft's official guidance is at learn.microsoft.com/dotnet/standard/net-standard.

People who actually shaped .NET

Original Microsoft team: Anders Hejlsberg (C# language designer, Distinguished Engineer; previously Turbo Pascal and Delphi at Borland; moved to Microsoft 1996), Patrick Dussud (CLR architect, Technical Fellow), Krzysztof Cwalina and Brad Abrams (Framework Design Guidelines; BCL conventions), Eric Lippert (C# language design and compiler), Jay Schmelzer (long-time Visual Studio leadership).

Mono / Xamarin lineage: Miguel de Icaza (Mono founder 2001, Xamarin co-founder, Distinguished Engineer at Microsoft 2016–2022), Nat Friedman (Xamarin co-founder, GitHub CEO 2018–2021), Joseph Hill (Xamarin co-founder).

Modern .NET team: Mads Torgersen (C# language design lead, current), Stephen Toub (performance lead; the public face of the annual "Performance Improvements in .NET N" mega-posts), Richard Lander (.NET runtime PM), Damian Edwards (ASP.NET Core lead, minimal APIs author), David Fowler (architect across many of the modern stacks — ASP.NET Core, Orleans, Aspire), Immo Landwerth (BCL / API surface). Public face: Scott Hanselman (long-running community-facing .NET evangelist), Scott Guthrie (Azure EVP, originally created ASP.NET in 2002).

The sibling and derived runtimes

Several runtimes branch off the main .NET tree:

  • Mono — the open-source CLR started in 2001 by Miguel de Icaza. Stewarded by Microsoft 2016–2024; handed off to the Wine project in 2024 as its long-term home.
  • .NET Native — the AOT-compiled UWP-only runtime; deprecated in favor of the modern native-AOT story.
  • Blazor — .NET running in the browser via WebAssembly (Blazor WebAssembly) or rendered on the server with DOM diffs over SignalR (Blazor Server) or hybrid (Blazor Hybrid in MAUI).
  • MAUI — .NET Multi-platform App UI; the Xamarin Forms successor for iOS / Android / macOS / Windows. Graduated in .NET 6 (2021).
  • Unity scripting — the Unity game engine embeds a forked Mono runtime; Unity has been working toward a native-AOT-based future under "CoreCLR" support, but as of the table's last update most shipping Unity titles still use the Mono fork.
  • dotnet/runtimelab — the public experimental sandbox for runtime-team work (Green Threads, Project Reunion-related code, and so on).

Find your version — in the terminal

The browser cannot detect what version of .NET is installed on your machine — there's no UA Client Hint or fingerprint that exposes it. Run one of these in your terminal to see your real install.

What's installed?

Print the active SDK, all installed SDKs / runtimes, or a full diagnostic dump.

$ dotnet --version          # active SDK (the one that runs `dotnet build`)
$ dotnet --list-sdks        # every SDK installed side-by-side
$ dotnet --list-runtimes    # every shared runtime (ASP.NET Core, WindowsDesktop, etc.)
$ dotnet --info             # full dump: OS, RID, install paths, environment

Pin a project to a specific SDK

Drop a global.json in the project root. Every dotnet command run there picks the matching SDK.

// global.json
{
  "sdk": {
    "version": "8.0.100",
    "rollForward": "latestMinor"
  }
}

rollForward values: patch, feature, minor, major, latestPatch, latestFeature, latestMinor, latestMajor, disable.

Install or upgrade a version

Multiple SDKs and runtimes can coexist; installing a new one doesn't remove old ones.

# macOS (Homebrew cask covers latest GA SDK)
$ brew install --cask dotnet-sdk

# Windows (winget)
> winget install Microsoft.DotNet.SDK.10
> winget install Microsoft.DotNet.SDK.8       # LTS

# Linux (Microsoft package feed)
# See: learn.microsoft.com/dotnet/core/install/linux

Lifecycle & upgrade nudges

Check for available updates and inspect installed workloads.

$ dotnet sdk check                  # newer SDKs available?
$ dotnet workload list              # maui, wasm-tools, ios, android, etc.
$ dotnet workload update            # pull latest for installed workloads

# Run a specific framework target without changing the global default:
$ dotnet run --framework net8.0
$ dotnet run --framework net10.0