C# on Linux: Series Introduction

Why Linux? The Case for More Options

[0:00 - 1:17] Tim opens with a candid observation: being locked into a single platform limits your flexibility. A previous video on Microsoft's AI-related changes to Windows prompted conversations about alternatives, and this series grew out of those discussions. The goal is not to abandon Windows but to add a second viable environment to your skill set.

Having that breadth carries real professional value. If a new job requires working on Mac or Linux, or if a deployment target runs on a Linux server, the developer who already knows the workflow has a clear advantage. Tim frames the series as a way to deepen your .NET knowledge by approaching it from a different angle, not as a platform war.

Choosing Linux Mint

[1:28 - 2:42] One thing that catches newcomers off guard is that "Linux" is not a single operating system. It is a kernel that sits underneath hundreds of distinct distributions, each with its own desktop environment, package manager defaults, and design philosophy. Tim acknowledges that the sheer number of choices can feel overwhelming, then simplifies the decision for this series: Linux Mint.

Mint strikes a balance between stability and familiarity. Its desktop layout resembles what Windows users already know, with a taskbar, a start menu equivalent, and a file manager that behaves predictably. That visual similarity eases the transition without pretending the two systems are identical. Other distributions like Pop!_OS are solid choices too, but Mint provides the most approachable starting point for developers whose muscle memory is built around Windows.

IDE Options for .NET Development

[2:42 - 3:57] Since Visual Studio is a Windows-only application, Linux developers need a different editor. Tim highlights two primary paths: VS Code paired with the C# Dev Kit extension, and JetBrains Rider.

VS Code with the C# Dev Kit has improved considerably over recent releases, though Tim notes that some rough edges remain. Licensing follows the same model as Visual Studio: free for individual developers and small teams, with a paid tier for larger organizations. JetBrains Rider now offers a free community edition for personal projects, giving developers a second option without an upfront cost. The series will lean toward VS Code but cover both, since each tool has strengths depending on the task at hand.

Machine Specs: What You Actually Need

[4:00 - 6:14] One of the most practical selling points for Linux is how little hardware it demands. Tim shares two examples that illustrate the range. First, he describes running VS Code with the C# Dev Kit on a Raspberry Pi keyboard computer, a device with roughly 400 MHz of processing power and a dual-core CPU. He built and ran a Blazor application on it. The experience was sluggish, but it worked.

The second example is more relatable for most developers. An old laptop that had become unusable under Windows 10 (clicks timing out, applications refusing to load) ran Linux Mint without issue after a fresh install. The same hardware that could barely render a Windows desktop became a functional development machine. Tim is clear that better specs still produce a better experience, but the minimum bar for C# development on Linux sits far lower than it does on Windows.

Project Types You Can and Cannot Build

[6:17 - 8:23] Not every .NET project type works outside of Windows, and understanding those boundaries upfront prevents frustration later. WinForms and WPF both depend on Windows-specific libraries baked into the operating system. UWP carries the same limitation. None of these will compile or run on Linux.

MAUI adds a subtlety worth noting. While it targets multiple platforms (Windows, macOS, iOS, Android), Linux is not among them. This distinction matters because developers sometimes assume "cross-platform" means "everywhere," when in practice MAUI's reach excludes both Linux and the web.

What does work covers a broad surface. Console applications, which form the foundation for learning C#, run without modification. Service applications (daemons in Linux terminology) are fully supported. The entire ASP.NET Core web stack, including APIs, Blazor apps, gRPC services, and worker services, operates identically on Linux. For desktop applications that need to span operating systems, Uno Platform comes up as a future topic in the series, allowing you to build from Linux and deploy to Windows and macOS as well.

What This Series Will Not Do

[8:37 - 11:52] Tim sets three expectations early. First, the series is not anti-Microsoft. GitHub, Azure, Edge, VS Code, and .NET itself are all Microsoft products, and several will appear throughout the series. The point is choosing which tools to adopt on your own terms rather than having them imposed on you.

Second, these episodes will not position Linux as the only correct choice. Windows remains the right environment for plenty of developers and workflows. Linux expands your options; it does not replace every scenario Windows handles well. The value lies in understanding both platforms so you can pick the one that fits a given situation.

Third, and perhaps most important for developers making the switch: do not expect Linux to work the same way as Windows. Installing software involves more command-line interaction. Package management follows a fundamentally different model. Some workflows that feel automatic on Windows require explicit steps on Linux. The series will walk through each of those differences as they arise, explaining why they exist and how to handle them.

Expect Differences, Not Deficiencies

[11:52 - 13:34] A common trap when switching platforms is measuring everything against what you already know. Tim addresses this directly: leaving Windows behind means accepting that certain tasks will look and feel unfamiliar. Window management, software installation, and system configuration all have their own conventions on Linux.

Some of those patterns are genuinely better. Linux's package manager model, for example, keeps your entire software stack updated through a single system rather than relying on each application to manage its own updater. Other differences simply take adjustment. Tim compares it to switching from Windows to Mac, where he installs a third-party tool to get the window-snapping behavior he prefers. The equivalent happens on Linux: you adapt the environment to your preferences over time, rather than expecting it to mirror what you left behind.

Wrapping Up: A Roadmap for the Series

[13:34 - 14:10] Tim closes by outlining what comes next. The series begins with installing Linux Mint on a USB drive so you can test the entire experience without touching your existing Windows installation. From there, subsequent episodes cover permanent installation, setting up development tools, and building real applications. Side-quest videos will address Linux-specific configuration tasks along the way.

Conclusion

[14:10 - 14:29] The takeaway from this introduction is straightforward: Linux is a viable, capable platform for C# and .NET development, with a few boundaries you should understand before diving in. The hardware requirements are modest, the tooling has matured, and the project types that matter most for modern development (web, API, services, console) all work without compromise.

For developers who have worked exclusively on Windows, this series offers a structured path to broadening your reach. Starting with a thumb drive means there is nothing to lose and a meaningful skill to gain.

Example Tip: Before committing to a full install, boot Linux Mint from a portable USB stick on your primary machine. You will get a feel for the desktop, the terminal, and the general workflow without altering your existing setup. If the experience clicks, you can move to a permanent installation knowing what to expect.

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