.NET SDK vs. .NET Runtime: What's the Difference?



If you are starting with .NET development, you have probably come across two terms: .NET SDK and .NET Runtime.

Both are essential parts of the .NET ecosystem, but they serve different purposes. The .NET SDK helps you build applications, while the .NET Runtime allows you to run them.

So, do you need the SDK, the Runtime, or both?

In this guide, we will explain the differences between the .NET SDK and .NET Runtime, when to install each one, and how to check which components are already installed on your computer.

What Is the .NET SDK?

The .NET SDK (Software Development Kit) is a collection of tools and libraries that developers use to create, build, test, and publish .NET applications.

If you are developing applications using C#, ASP.NET Core, or other .NET technologies, the SDK is what you generally need to get started.

The .NET SDK includes:

  • .NET CLI: Command-line tools for creating and managing projects.

  • C# compiler: Compiles your C# source code.

  • Build tools: Build your application and resolve dependencies.

  • Project templates: Create console applications, web APIs, class libraries, and more.

  • .NET reference libraries: Provide the APIs needed to develop applications.

  • Runtime components: Include the runtime components required for the SDK's supported workflows.

For example, you can create a new console application using this command:

dotnet new console -n MyFirstApp

Move into the project directory:

cd MyFirstApp

Build the application:

dotnet build

Run it:

dotnet run

These commands demonstrate why the SDK is essential for development. It provides the tools needed to create, compile, and execute your application.

What Is the .NET Runtime?

The .NET Runtime provides the environment required to execute a .NET application.

When an application is compiled, its output typically includes Intermediate Language (IL) code and metadata. At execution time, the .NET runtime provides services such as managed code execution, garbage collection, exception handling, and other runtime functionality.

The runtime is designed primarily for running applications rather than developing them.

The .NET Runtime includes components such as:

  • CoreCLR: The runtime responsible for executing managed code in the standard CoreCLR-based .NET implementation.

  • Garbage collector: Automatically manages memory for managed objects.

  • Base class libraries: Provide common functionality used by .NET applications.

  • JIT compiler: Converts Intermediate Language into native machine code during execution.

The exact components depend on the .NET implementation and deployment model.

For example, if someone gives you a compatible, framework-dependent .NET application, you may only need the appropriate runtime to execute it.

You do not necessarily need the full SDK on a computer used only to run that application.



.NET SDK vs. .NET Runtime: Key Differences

The simplest way to understand the difference is to compare their purposes.

Feature.NET SDK.NET Runtime
Primary purposeDevelop .NET applicationsRun .NET applications
Create new projectsYesNo
Compile C# source codeYesNo
Build applicationsYesNo
Execute compatible .NET applicationsYes, with the required runtimeYes
Includes development toolsYesNo
Best suited forDevelopersEnd users and application servers
Required for everyday .NET developmentYesIncluded in the standard SDK installation

Remember: Installing the SDK is usually sufficient for a developer's local machine because the SDK installation includes the runtime components it needs. A production server may need only the appropriate runtime, depending on how the application is deployed.

Do You Need the .NET SDK or Runtime?

The answer depends on what you want to do.

1. If You Are Learning C#

Install the .NET SDK.

You will need it to create projects, compile your code, and run your applications from the command line.

For example:

dotnet new console
dotnet build
dotnet run

Without the SDK, these development workflows will not be available through a standard .NET installation.

2. If You Are Developing ASP.NET Core Web APIs

Install the .NET SDK that supports your target framework.

For example, if you are developing an ASP.NET Core application targeting .NET 10, install a compatible .NET 10 SDK.

The SDK provides the tools to build and publish the application. For local execution, the appropriate ASP.NET Core runtime components must also be available.

3. If You Only Want to Run a .NET Application

You may need only the runtime.

For example, imagine that your company distributes a framework-dependent .NET application. If the application targets a particular supported .NET version, the computer running it must have the required runtime installed.

You do not need to install the full SDK just to run that application.

However, some applications are published as self-contained deployments or Native AOT applications. These can have different runtime requirements, so check the application's deployment instructions.

4. If You Are Deploying an ASP.NET Core Application

The hosting requirements depend on your deployment environment.

  • Development machine: Install the SDK.

  • Linux or Windows server: Install the required runtime or use a suitable self-contained deployment.

  • IIS hosting on Windows: You may need the ASP.NET Core Hosting Bundle, which includes the ASP.NET Core Module and the relevant runtime components.

  • Docker: Choose a suitable SDK image for building and a runtime or ASP.NET image for running a framework-dependent application.

Using the right installation keeps production environments leaner and avoids installing unnecessary development tools.

How to Check Whether the .NET SDK Is Installed

You can use the .NET CLI to check your installation.

Open Command Prompt, PowerShell, or a terminal and run:

dotnet --version

This displays the active SDK version, if an SDK is available.

To list all installed SDKs, run:

dotnet --list-sdks

Example output:

8.0.408
9.0.203
10.0.100

The versions shown above are illustrative. Your actual output depends on the SDKs installed on your machine.

How to Check Which .NET Runtimes Are Installed

Run the following command:

dotnet --list-runtimes

Example output:

Microsoft.NETCore.App 10.0.0
Microsoft.AspNetCore.App 10.0.0

The output lists the installed runtime versions and their installation paths.

The two entries represent different runtime components:

  • Microsoft.NETCore.App: The core .NET runtime.

  • Microsoft.AspNetCore.App: The shared framework used by ASP.NET Core applications.

Your installed versions may differ.

You can also run:

dotnet --info

This provides additional information about the .NET environment, including installed SDKs, runtimes, operating system details, and architecture.

What Happens If You Install the Runtime Without the SDK?

Your computer can run compatible framework-dependent applications, but you will not have the complete set of tools needed for standard .NET development.

For example, the following command requires an SDK:

dotnet new webapi

If no SDK is available, the CLI may report that no SDK was found.

Similarly, the following command requires an SDK to build a project:

dotnet build

However, running an existing compatible application may work with the required runtime installed.

This is why runtime-only installations are common on production servers and end-user computers.

Can You Install Multiple .NET SDKs and Runtimes?

Yes. You can install multiple versions of the .NET SDK and runtime side by side.

For example, you might have projects targeting .NET 8, .NET 9, and .NET 10 on the same development machine.

Each project can target its required framework, provided the corresponding SDK and runtime requirements are satisfied.

The SDK selected for a project can also be influenced by a global.json file in the project directory or its parent directories.

This flexibility is useful when maintaining older applications while developing new ones.

Keep in mind that installing a newer runtime does not automatically mean that every older or newer application will run without compatibility considerations.

How to Install the .NET SDK

If you are setting up a development environment for the first time, download the appropriate SDK from Microsoft's official .NET website.

Official download page:

https://dotnet.microsoft.com/download

Choose the SDK for your operating system, whether you use Windows, Linux, or macOS.

After installation, open a new terminal and verify it:

dotnet --version
dotnet --list-sdks
dotnet --list-runtimes

If you want detailed, step-by-step installation instructions, read our guide:

How to Install .NET 10 SDK on Windows, Linux, and macOS

Note: Replace the link above if your actual .NET 10 installation article has a different URL.

Frequently Asked Questions

Is the .NET SDK the same as the .NET Runtime?

No. The SDK provides development tools for creating, building, and publishing applications. The Runtime provides the environment needed to execute compatible .NET applications.

Does installing the .NET SDK install the Runtime?

A standard SDK installation includes the runtime components needed by that SDK's supported workflows. You can verify the exact installed components with dotnet --list-runtimes.

Can I run C# code without installing the .NET SDK?

Yes, in certain situations. You can run an already-built, compatible application if its required runtime is available. However, the standard .NET SDK is needed for the usual project creation and build workflows.

Do I need the ASP.NET Core Runtime for a console application?

Usually, no. A typical framework-dependent console application needs the Microsoft.NETCore.App runtime. An ASP.NET Core application generally needs Microsoft.AspNetCore.App as well.

Should I install the SDK on a production server?

Usually, it is unnecessary. A production server generally needs only the components required to run the application. Self-contained and Native AOT deployments may have different requirements.

Is the .NET Runtime free?

Yes. The .NET Runtime is available at no cost under Microsoft's applicable open-source licensing terms. You can download it from the official .NET download page.

Final Thoughts

The difference between the .NET SDK and the .NET Runtime is straightforward:

  • SDK = Build and develop applications.

  • Runtime = Run applications.

If you are learning C#, developing ASP.NET Core APIs, or building .NET applications professionally, start by installing the appropriate SDK. If you only need to execute an existing framework-dependent application, the required runtime may be all you need.

Understanding this distinction will help you set up your development environment correctly, troubleshoot missing SDK or runtime errors, and choose the right deployment approach.

Next step: Check your installed SDKs and runtimes with dotnet --list-sdks and dotnet --list-runtimes. You may already have everything you need.

Comments

Post a Comment

Popular posts from this blog

How to Install .NET 10 SDK on Windows, Linux, and macOS

Image
 If you want to start developing applications with .NET 10 , the first step is to install the .NET 10 SDK on your computer. The .NET SDK includes the tools required to create, build, run, test, and publish .NET applications. It also includes the corresponding .NET runtime. In this tutorial, you'll learn: What you need to install for .NET 10 development How to install .NET 10 on Windows How to install .NET 10 using WinGet How to install .NET 10 on macOS How to install .NET 10 on Linux How to verify the installation How to create your first .NET 10 application How to troubleshoot common installation problems What Is .NET 10? .NET 10 is a cross-platform development platform from Microsoft that can be used to build: Web applications REST APIs Console applications Desktop applications Cloud applications Microservices Background services Libraries AI-powered applications .NET 10 is an LTS (Long Term Support) release. The official Microsoft d...
Read more

Microsoft Agent Framework Explained: A .NET Developer’s Architecture Guide

Image
Microsoft Agent Framework brings together agents, workflows, tools, memory, AI models, MCP, multi-agent orchestration, and observability into a single architecture. At first, that can feel overwhelming. There are a lot of concepts to learn: Agents Workflows Sessions Middleware Memory AI models Tool calling MCP Multi-agent systems Observability The individual pieces are easy enough to understand. The difficult part is understanding how they fit together . That is where an architecture diagram helps. Instead of starting with code, let's look at Microsoft Agent Framework from a .NET developer's perspective. The Big Picture Think of an AI agent as an intelligent application built from familiar software engineering components. A typical request might look like this: "Analyze last month's sales, identify the top-performing products, create a PowerPoint summary, and email it to the management team." A traditional application would follow a predefined sequence of API call...
Read more

Why Is Your ASP.NET Core API Using So Much Memory? 7 Causes and Fixes

Image
  Why Is Your ASP.NET Core API Using So Much Memory? 7 Causes and Fixes If your ASP.NET Core API is consuming more and more memory, you might immediately suspect a memory leak. Sometimes you're right. But here's the problem: High memory usage doesn't always mean you have a memory leak. An ASP.NET Core API can consume a surprising amount of RAM because of large object allocations, inefficient database queries, unbounded caching, excessive logging, incorrect lifetime management, or simply because the .NET Garbage Collector hasn't returned memory to the operating system yet. I've seen developers try to fix these problems by increasing server RAM. That's usually treating the symptom instead of the cause. In this article, we'll look at 7 common reasons ASP.NET Core APIs use too much memory — and what you can do about them. 1. Loading Too Much Data Into Memory One of the easiest ways to make an API consume memory is to retrieve an enormous amount of data from the ...
Read more