How to Install and Use .NET (C#) on Ubuntu 26.04 and 24.04

• Use Ubuntu 26.04 LTS or 24.04 LTS Desktop or Server, internet access and an account with sudo access. On Ubuntu Desktop, open Terminal with Ctrl+Alt+T.
• Keep your release’s normal updates and security repositories enabled. Package availability depends on your architecture and enabled sources; check the candidate if installation fails.
• Use sudo for APT only. Create projects, restore packages and run code as your normal user.
• If .NET is already installed, identify its source before adding another installation. This guide uses Canonical’s APT packages.
• The examples use Bash and a new practice directory under your home folder. No editor, Microsoft account or paid IDE is required.

Read the release and look for existing .NET installations:

cat /etc/os-release
dpkg --print-architecture
type -a dotnet

Expect Ubuntu 26.04 or 24.04. A missing dotnet command is normal before installation. If it exists, run dotnet --list-sdks and check whether it came from APT, Snap or a manual installation. Avoid adding a second route just to fix a PATH problem.

Run the same command on either Ubuntu release:

sudo apt update && sudo apt install -y dotnet-sdk-10.0

The && runs installation only after the package-list update succeeds; -y accepts APT’s confirmation automatically. The SDK pulls in its matching runtimes and dependencies. You do not need the runtime-only packages as an extra step.

Starting with Ubuntu 24.04 and continuing in 26.04, Microsoft no longer publishes .NET packages for these releases to its APT repository. Canonical maintains .NET in Ubuntu’s feeds. Do not install packages-microsoft-prod.deb for this guide.

Do not mix Ubuntu and Microsoft .NET packages: different layouts and dependencies can cause missing runtime or host errors. A Microsoft repository may still be needed for another product; do not remove it blindly. See Microsoft’s Ubuntu packaging guidance.

After APT finishes, check:

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

The SDK list should include a 10.0.xxx entry. The runtime list should include Microsoft.NETCore.App and Microsoft.AspNetCore.App 10.0.x. The SDK and runtime patch numbers use different formats; they do not need to match. dotnet --version reports the SDK selected in your current directory.

As of November 2026, Microsoft’s two actively supported modern .NET releases are .NET 10 LTS and .NET 11 STS. Both are supported through November 14, 2028, provided you keep up with servicing updates. .NET 11 includes C# 15. This guide uses .NET 10 as the default.

.NET 8 and .NET 9 reached Microsoft End of Support on November 10, 2026. An old tutorial or an available package is not a reason to choose them for a new project. Canonical’s support policy for its Ubuntu builds is separate from Microsoft’s upstream lifecycle. Check the .NET support policy when maintaining an existing application.

Use a unique folder so an existing HelloApp project is left alone:

dotnet_demo_dir=$(mktemp -d "$HOME/dotnet-demo.XXXXXX") &&
cd "$dotnet_demo_dir"

Keep this terminal open. pwd shows the folder’s actual name. The examples below assume you are working here and have the .NET 10 SDK selected.

Generate the console template, enter its directory and run it:

dotnet new console -o HelloApp
cd HelloApp
dotnet run

Expect Hello, World!. The template creates HelloApp.csproj (project settings) and Program.cs (your source). It normally restores dependencies automatically. With only the .NET 10 SDK installed, the project targets net10.0; see the side-by-side section if you also installed .NET 11.

While inside HelloApp, replace only this practice project’s Program.cs with:

cat > Program.cs <<'CS'
Console.WriteLine("Hello from C# on Ubuntu!");
CS
dotnet run

This overwrites the template’s greeting. Do not paste it into an existing project with source you need to keep. Console.WriteLine prints one line; modern C# allows this short form without writing a Main method yourself.

From inside HelloApp, add the JSON library:

dotnet add package Newtonsoft.Json

NuGet downloads the package and records its resolved version in the project file. dotnet package add Newtonsoft.Json is the newer noun-first form in .NET 10; the command above also works. Choose packages you trust: adding one changes your project’s dependencies. See the package command reference.

Replace the practice file again, then run it:

cat > Program.cs <<'CS'
using Newtonsoft.Json;

var message = new { Greeting = "Hello", Platform = "Ubuntu" };
string json = JsonConvert.SerializeObject(message);
Console.WriteLine(json);
CS
dotnet run

The anonymous object holds two values. JsonConvert.SerializeObject converts them into JSON text, which the program prints:

From the HelloApp directory:

dotnet build

A successful build reports zero errors. Build compiles your project and restores dependencies when needed; it does not launch the program. Read any warnings rather than assuming success means the code has no problems.

Prepare the application files for deployment:

dotnet publish -c Release

For the .NET 10 project above, the default publish directory is bin/Release/net10.0/publish/. The command prints the actual output path. Repeating it updates generated files. This normal framework-dependent publish still needs the matching runtime on the destination machine.

For the net10.0 example, run:

dotnet bin/Release/net10.0/publish/HelloApp.dll

Expect the same JSON output. Keep the whole publish directory when copying this app, including its dependency and runtime configuration files. A project targeting another framework has a different directory name. dotnet publish -c Release does not automatically produce one self-contained executable; see the publish reference for deployment options.

Canonical describes these PPA packages as best-effort support and not intended for production use. Use this optional route for development and testing. Microsoft’s upstream .NET 11 support dates do not change Canonical’s support terms for these packages.

This adds a repository and can affect package candidates for later updates. Review the repository information before accepting:

sudo apt update && sudo apt install -y software-properties-common
sudo add-apt-repository ppa:dotnet/backports
sudo apt update
apt policy dotnet-sdk-11.0

software-properties-common provides add-apt-repository. Confirm a candidate exists for your release and architecture, from the dotnet/backports PPA. Do not add a repository for a different Ubuntu release if it is missing.

Keep .NET 10 installed and add .NET 11:

sudo apt install dotnet-sdk-11.0
dotnet --list-sdks

The list should now include both 10.0 and 11.0 SDKs. Canonical’s .NET 11 announcement describes its Ubuntu packaging. Prefer this APT route when your existing installation also uses APT.

Without a global.json selection, the CLI normally chooses the highest installed SDK. After adding .NET 11, a plain dotnet new console can therefore create a net11.0 project. To use the .NET 10 SDK, select it explicitly before creating the project.

dotnet --list-sdks

In your practice root, create a global.json file with the following content. Replace 10.0.100 with the complete installed 10.0 SDK version shown above. Do not overwrite an existing global.json without reviewing its purpose:

{
  "sdk": {
    "version": "10.0.100",
    "rollForward": "latestPatch"
  }
}

Save this as global.json using your editor, not as a terminal command. Run dotnet --version from that directory to verify selection. The file applies to its directory and descendants. latestPatch stays within the selected SDK feature band; review the pin when moving to another band. Choosing an SDK is separate from changing a project’s TargetFramework. See .NET version selection.

This changes into a new directory outside the project:

dotnet_script_dir=$(mktemp -d "$HOME/dotnet-script.XXXXXX") &&
cd "$dotnet_script_dir" &&
cat > hello.cs <<'CS'
Console.WriteLine("Hello from a single C# file!");
CS
dotnet run hello.cs

Expect Hello from a single C# file!. You still need the SDK. dotnet run --file hello.cs explicitly selects file mode when you need to avoid ambiguity. These are file-based C# apps, not shell scripts.

Check the release and configured package candidate:

cat /etc/os-release
sudo apt update
apt policy dotnet-sdk-10.0

On 24.04 and 26.04, keep the normal release, updates and security sources enabled. Resolve update or mirror errors first. If the architecture has no candidate, follow Canonical’s supported packaging options; do not install DEBs from another Ubuntu release.

A runtime-only installation cannot build projects. Check the selected command and the SDK list:

type -a dotnet
dotnet --info
dotnet --list-sdks

Install dotnet-sdk-10.0 if you only installed a runtime. If APT, Snap and ~/.dotnet copies coexist, identify which executable is selected before changing PATH. Do not create guessed symlinks between installation roots.

Inspect APT sources and installed versions:

apt policy dotnet-sdk-10.0 dotnet-runtime-10.0 aspnetcore-runtime-10.0

Packages from mixed Microsoft and Ubuntu feeds can cause these errors. Follow the official package-mix-up repair guide for your installation. Preserve project files and review which apps depend on each runtime before removing packages. Do not run a broad dotnet* purge as a first fix.

Check dotnet --list-sdks and read any global.json in the project directory or its parents. It may request a version you do not have. Install the supported SDK required by the project or deliberately update its pin. Do not delete a team’s pin just to hide the error.

Return to HelloApp and retry restore to see the underlying error:

dotnet restore

Check internet access, the system clock, NuGet sources and any managed proxy or certificate settings. Do not disable TLS verification. A missing Newtonsoft namespace usually means the package was not restored or was added to a different project.

Run project commands inside HelloApp, where HelloApp.csproj lives. Linux filenames are case-sensitive. For a file-based app, use the separate script directory. Do not keep hello.cs alongside Program.cs in the console project.

Fix the reported repository, SDK selection or network problem first. Then verify dotnet --list-sdks. For an existing HelloApp project, return to its directory and rerun dotnet restore, dotnet build and dotnet run. You do not need to recreate the project or overwrite Program.cs to recover from a restore failure.

Install available updates for packages already on your system:

sudo apt update && sudo apt upgrade

Review APT’s changes. This upgrades other installed Ubuntu packages too and can restart services. Schedule updates appropriately on a server. It does not switch a net10.0 project to net11.0 or update its NuGet references; rebuild and test applications after updating.

Before removal, check which projects and tools depend on the SDK. Review APT’s proposed removals:

sudo apt remove dotnet-sdk-10.0

This removes the SDK package, not your HelloApp source directory. Runtime dependencies may remain installed. If you installed .NET 11, remove it separately with sudo apt remove dotnet-sdk-11.0.