How to Install .NET 10 on Linux Mint

Why the Terminal Matters on Linux

[0:49 - 1:23] Tim starts by acknowledging something Windows developers often resist: on Linux, the terminal is the default way to get things done. But he makes a practical case for it. Terminal commands are precise and scriptable. When a GUI changes its layout, every tutorial with screenshots becomes outdated. Terminal instructions stay accurate for years.

For .NET setup specifically, the commands are straightforward and repeatable across any Debian-based distribution.

Updating the Package Manager

[1:23 - 1:56] Before installing anything, run the package list update:

// Terminal command (not C#, run in your Linux terminal)
sudo apt update

// Terminal command (not C#, run in your Linux terminal)
sudo apt update

This command doesn't actually install or upgrade anything. It refreshes the local index of available packages so that apt knows what versions are current. Think of it as syncing your package catalog before shopping.

Installing the .NET 10 SDK

[1:56 - 3:46] With the package list updated, install the SDK:

sudo apt install dotnet-sdk-10.0

sudo apt install dotnet-sdk-10.0

Tim makes an important distinction here between the SDK and the runtime. The runtime is what you'd install on a production server that only needs to run .NET applications. The SDK is larger because it includes the compiler, build tools, and project templates on top of the runtime. For development work, you always want the SDK.

One practical tip from the video: running this command while disconnected from the internet produces a wall of cryptic errors. The fix is simply connecting to the network. It's an easy thing to overlook, especially on a laptop that might not auto-connect on Linux the way it does on Windows.

Verifying the Installation

[3:46 - 4:06] Once the install completes, verify it:

dotnet --version

dotnet --version

The output shows something like 10.0.103. Notice that you didn't specify that patch number during installation. The package manager grabbed the latest available version of the .NET 10 SDK automatically.

Creating a Working Directory

[4:06 - 5:01] Before writing any code, set up a folder for demo files. The video shows both the terminal and the desktop file manager side by side:

// Terminal commands
ls              // List current directory contents
mkdir demos     // Create a new folder
cd demos        // Move into it
ls              // Verify it's empty

// Terminal commands
ls              // List current directory contents
mkdir demos     // Create a new folder
cd demos        // Move into it
ls              // Verify it's empty

The same folder shows up in the file manager ("Files" on Linux Mint), which reinforces the point that terminal and GUI operations work on the same filesystem. You can use whichever you prefer, or both.

Creating and Running a Single C# File

[5:01 - 8:14] Here's where Tim highlights a feature in .NET 10 that changes the quick-testing workflow significantly. You can run a standalone .cs file directly, with no .csproj, no solution file, and no Program.cs boilerplate.

Create the file with touch:

// Create an empty file
touch demo1.cs

// Create an empty file
touch demo1.cs

Then open it in nano, a terminal-based text editor:

// Open in the terminal editor
nano demo1.cs

// Open in the terminal editor
nano demo1.cs

Inside the editor, he types a single line of C#:

Console.WriteLine("Hello World");

Console.WriteLine("Hello World");

After saving with Ctrl+X, Y, and Enter, he runs it:

// Execute the .cs file
dotnet run demo1.cs

// Execute the .cs file
dotnet run demo1.cs

The first execution takes a moment to compile, then prints Hello World. Just a file and a command.

Building Something More Interactive

[8:17 - 10:27] A second example demonstrates user input and string interpolation:

touch demo2.cs

touch demo2.cs

Opening it in Xed (Linux Mint's default text editor), Tim writes:

Console.Write("What is your first name? ");
string? name = Console.ReadLine();
Console.WriteLine($"Hello {name}");

Console.Write("What is your first name? ");
string? name = Console.ReadLine();
Console.WriteLine($"Hello {name}");

Tim catches a bug while typing, initially writing Console.Read instead of Console.Write. Without IntelliSense, these slips are easy to make.

Running the file:

dotnet run demo2.cs

dotnet run demo2.cs

The program asks for a name, Tim types "Tim", and it outputs "Hello Tim". The full C# development loop (edit, compile, run, interact) requires nothing more than a text editor and the SDK.

The Value of Working Without an IDE

[8:41 - 9:54] Tim makes a broader point here: every developer should occasionally write C# without an IDE. Not because IDEs are bad, but because they fill in so many gaps (semicolons, closing brackets, correct method names) that you can lose touch with the fundamentals. Spending time in a plain text editor on Linux is a good way to sharpen those basics.

For real development work, VS Code with the C# Dev Kit is the preferred editor across all platforms, and JetBrains Rider now offers a free community edition for personal projects. Both work identically on Windows, macOS, and Linux.

Exploring Project Templates

[10:34 - 11:42] Beyond single-file execution, there are full project templates available:

dotnet new list

dotnet new list

Running that command displays everything available: console apps, web APIs, Blazor apps, class libraries, and more. If you wanted to create a standard console application:

dotnet new console -n MyApp
cd MyApp
dotnet run

dotnet new console -n MyApp
cd MyApp
dotnet run

This creates the familiar project structure with a .csproj file and Program.cs. From there, you can add NuGet packages, reference other projects, and build anything you'd build on Windows.

Wrapping Up: From Install to Running Code in Minutes

[11:42 - 13:05] Tim closes by encouraging developers to spend time with the terminal-only workflow before reaching for an IDE. The .NET SDK installs through Linux's standard package manager in a single command, and the tools you get (building, running, templating, and single-file execution) are identical to what you'd have on Windows or macOS.

What the walkthrough reinforces is that the learning curve here isn't about C# or .NET. It's about becoming comfortable with a different workflow, and that comfort comes quickly.

Conclusion

[13:05 - 13:41] To sum it up: getting .NET 10 running on Linux takes two commands (sudo apt update and sudo apt install dotnet-sdk-10.0), and from there you can write and run C# immediately. Working in the terminal is a practical skill that transfers directly to every Linux-based deployment environment you'll encounter.

So next time you're setting up a new machine or spinning up a Linux VM, the full .NET development experience is a few minutes away.

Example Tip: If you're testing a quick idea or debugging a specific behavior, skip dotnet new console entirely. Just create a .cs file, write your code, and run it with dotnet run filename.cs. It's the fastest path from idea to execution in .NET 10.

Watch full video on his YouTube Channel and gain more insights on developing C# on Linux.