What is .NET? Runtime, SDK, frameworks and languages
People say “.NET” to mean several things at once: a runtime that executes code, a large standard library, a command-line SDK, a family of languages, and the application frameworks (ASP.NET Core, Blazor, .NET MAUI, WPF) built on top. This page separates those layers so the rest of the section makes sense. It also explains how today’s .NET relates to the older, Windows-only .NET Framework, which application framework fits which kind of app, and how to get a first program running.
.NET is free, open source (MIT license, developed on GitHub under the dotnet organization) and cross-platform: it runs on Windows, Linux and macOS on x64 and Arm64. At the time of writing (November 2026) the supported releases are .NET 10 (LTS, supported until November 2028) and .NET 11 (STS, released November 2026, also supported until November 2028).
The sample on this page is a file-based program: save it as intro.cs and run dotnet run intro.cs with the .NET 10 SDK or later. It was run with .NET SDK 10.0.115.
Topics on this page
Section titled “Topics on this page”| Topic | What it answers |
|---|---|
| Runtime libraries and SDK | Which parts make up “.NET” and what each one does. |
| NET and NET Framework | How modern .NET differs from .NET Framework 4.x, and when the old one still matters. |
| Application frameworks | Which framework to use for web, desktop, mobile, background and cloud work. |
| Languages | C#, F# and Visual Basic, and how they share one runtime. |
| Getting started | Installing the SDK and running a first program. |
Runtime libraries and SDK
Section titled “Runtime libraries and SDK”The runtime (CoreCLR) loads compiled code and runs it. Compilers for C#, F# and Visual Basic do not produce machine code; they produce Intermediate Language (IL) packaged in assemblies (.dll files). At run time the just-in-time (JIT) compiler turns IL into native code for the current CPU, and the garbage collector manages memory, so you allocate objects and never free them by hand. Tiered compilation starts methods quickly with a cheap JIT pass and recompiles hot methods with full optimizations. Native AOT is the alternative for apps that must start instantly: it compiles everything ahead of time at publish (see Native AOT).
The base class library (BCL) is the standard library: collections, LINQ, file and network I/O, HttpClient, JSON (System.Text.Json), cryptography, threading and async/await. The Microsoft.Extensions.* libraries add the building blocks most apps share: dependency injection, configuration, logging, options and hosting.
The SDK is what you install as a developer. It contains the compilers, MSBuild, NuGet and the dotnet CLI (dotnet new, build, test, run, publish). Machines that only run apps need just a runtime, or nothing at all for self-contained and Native AOT deployments.
using System.Globalization;using System.Runtime.InteropServices;
Console.WriteLine($"Runtime: {RuntimeInformation.FrameworkDescription}");Console.WriteLine($"OS arch: {RuntimeInformation.OSArchitecture}");
Order[] orders =[ new("ORD-1001", [new("Keyboard", 49.99m, 2), new("USB-C cable", 9.50m, 3)]), new("ORD-1002", [new("Monitor", 189.00m, 1)]),];
var culture = CultureInfo.GetCultureInfo("en-US");foreach (var order in orders){ Console.WriteLine($"{order.Number}: {order.Lines.Count} lines, total {order.Total.ToString("C", culture)}");}
record OrderLine(string Product, decimal UnitPrice, int Quantity){ public decimal LineTotal => UnitPrice * Quantity;}
record Order(string Number, List<OrderLine> Lines){ public decimal Total => Lines.Sum(l => l.LineTotal);}Output (the runtime line depends on your installed patch version and CPU):
Runtime: .NET 10.0.15OS arch: X64ORD-1001: 2 lines, total $128.48ORD-1002: 1 lines, total $189.00Pitfalls:
- SDK and runtime versions are different numbers. SDK 10.0.115 ships runtime 10.0.15. Pin the SDK with
global.jsonin CI so builds are repeatable. - Install servicing updates. Only the latest patch of a supported release is supported; apps roll forward to the newest installed patch of their major version.
NET and NET Framework
Section titled “NET and NET Framework”.NET Framework (1.0 in 2002 to 4.8.1 in 2022) is the original, Windows-only implementation. It is still supported as a component of Windows, but it receives only security and reliability fixes; 4.8.1 is the last version and no new features are coming. .NET Core (2016) was a cross-platform rewrite, and from .NET 5 (2020) the product is simply called “.NET”. .NET 5 did not merge .NET Framework into .NET Core: the two remain separate products, and moving an app from one to the other is a migration, not an upgrade.
| Modern .NET (5 and later) | .NET Framework 4.x | |
|---|---|---|
| Platforms | Windows, Linux, macOS | Windows only |
| New features | Yearly major release every November | None; servicing only |
| Side by side | Many versions per machine, or self-contained | One 4.x version per machine |
| Web stack | ASP.NET Core | ASP.NET (Web Forms, MVC 5, Web API 2) |
| Not available | Web Forms, WCF server, Windows Workflow | Minimal APIs, Native AOT, containers on Linux |
Choose modern .NET for every new project. Keep .NET Framework only for existing apps that depend on Web Forms, WCF server hosting or Windows-only libraries with no replacement. Individual 4.x versions have their own end dates: 4.5.2, 4.6 and 4.6.1 ended support in April 2022, and 4.6.2 ends in January 2027, so a 4.6.x app should at least move to 4.8.1.
Pitfalls:
- “.NET 5 unified everything” is a myth. .NET Framework code does not run on .NET 10 unchanged; use the .NET Upgrade Assistant and check for unsupported APIs.
- .NET Standard is for libraries, not apps. Target
netstandard2.0only for a library that must load in both .NET Framework and modern .NET.
Application frameworks
Section titled “Application frameworks”Every application framework below runs on the same runtime and BCL, so skills and libraries carry over between them.
| Framework | Builds | Platforms |
|---|---|---|
| ASP.NET Core | Web APIs (Minimal APIs or controllers), MVC and Razor Pages sites, gRPC, SignalR | Windows, Linux, macOS, containers |
| Blazor | Interactive web UI in C#, rendered on the server or in the browser with WebAssembly | Any modern browser |
| .NET MAUI | Native mobile and desktop apps from one code base | Android, iOS, macOS, Windows |
| WPF and Windows Forms | Windows desktop apps | Windows only |
| Worker services | Long-running background processes (queue consumers, schedulers) | Windows, Linux, macOS |
| Entity Framework Core | Object-relational mapping for SQL Server, PostgreSQL, SQLite and others | Library, used by any app |
| ML.NET and Microsoft.Extensions.AI | Machine-learning models and a common abstraction over AI chat and embedding services | Library |
The ASP.NET Core building blocks (dependency injection, middleware, Minimal APIs) are covered in .NET core features, and API design in the Web API section.
Pitfalls:
- WPF and Windows Forms are not cross-platform. They run on modern .NET, but only on Windows; use .NET MAUI or a web UI for other platforms.
- Game engines are separate. Unity uses C# with its own runtime and release schedule, so .NET version numbers do not map one to one.
Languages
Section titled “Languages”C# is the main language: statically typed, object-oriented with strong functional features (records, pattern matching, LINQ), and released yearly with .NET (C# 14 with .NET 10, C# 15 with .NET 11). F# is a functional-first language that is excellent for data processing and domain modeling. Visual Basic is supported and stable but no longer gains new language features. All three compile to IL, so a C# app can reference an F# library directly. See the C# section for the language itself.
Pitfalls:
- The language version follows the target framework. A project targeting
net8.0uses C# 12 by default; raisingLangVersionbeyond the default is unsupported.
Getting started
Section titled “Getting started”Install the SDK from the official download page (or winget install Microsoft.DotNet.SDK.10 on Windows, or your Linux package manager), then check it with dotnet --info. Create projects from templates:
dotnet new console -o OrdersPortal.Cli # console appdotnet new webapi -o OrdersPortal.Api # ASP.NET Core Web APIdotnet new xunit -o OrdersPortal.Tests # test projectdotnet run --project OrdersPortal.CliSince .NET 10 you can also run a single .cs file without a project (dotnet run intro.cs), which is how the samples in this section are written. Directives at the top of the file such as #:package Polly.Core@8.9.1 add NuGet packages. Use Visual Studio 2026, Visual Studio Code with the C# Dev Kit, or JetBrains Rider as the editor.
Pitfalls:
- File-based apps need the .NET 10 SDK. Older SDKs report that the file is not a project; convert to a project with
dotnet project convertwhen it grows.
Interview questions
Section titled “Interview questions”What is the difference between the .NET runtime and the .NET SDK?
The runtime executes compiled apps (JIT, garbage collector, BCL). The SDK is a superset for developers: compilers, MSBuild, NuGet and the dotnet CLI. Production servers need only the runtime, or neither for self-contained and Native AOT apps.
What does the JIT compiler do, and when would you avoid it? It compiles IL to native code on first call, with tiered compilation recompiling hot methods. Avoid it when startup time or memory matters more than peak throughput (serverless functions, CLI tools, scale-to-zero containers), using Native AOT, or partially with ReadyToRun.
Is .NET Framework dead? No new features, but it is supported as part of Windows and receives security fixes. 4.8.1 is the final version. New work belongs on modern .NET.
What is the difference between LTS and STS releases? Even-numbered releases are LTS with three years of support; odd-numbered ones are STS with two years. Both are production quality; LTS suits apps that upgrade rarely.
Senior scenario: a team runs a .NET Framework 4.6.2 Web API on Windows Server and wants to move to Linux containers. How do you plan it?
First move the box to a supported framework (4.8.1) because 4.6.2 support ends in January 2027. Then assess dependencies with the .NET Upgrade Assistant and API analyzers, move shared libraries to netstandard2.0 or multi-target so both apps can use them, and port the API to ASP.NET Core incrementally (for example behind a YARP reverse proxy that routes migrated endpoints to the new service). Replace Windows-only pieces (registry, WCF server, System.Web) and test on Linux early.
Related pages
Section titled “Related pages”- .NET section overview
- .NET core features: DI, middleware, Minimal APIs, Native AOT
- .NET versions and .NET evolution
- ASP.NET Core Web API introduction
- C# section