The Complete Guide to Setting Up a Production-Ready .NET 10 Development Environment in 2026

Set up a team-friendly .NET 10 development environment that mirrors CI/CD pipelines. This guide covers Windows (with WSL), macOS, and Linux setups using VS Code or Visual Studio 2026, with exact commands, version pinning via global.json, and team standardization through .editorconfig and analyzers. Skip the setup drift, get everyone on the same page from day one.

Post

Why This Setup Matters

Before diving into installation steps, let's understand why a standardized development environment is critical for professional teams:

Stability: Pinning SDK versions prevents the "it works on my machine" syndrome. When everyone uses the same .NET SDK version, builds are predictable and debugging becomes straightforward.

Reproducibility: A new team member should be able to clone your repository and have a working environment within minutes. No tribal knowledge required.

CI Parity: Your local environment should mirror your CI/CD pipeline as closely as possible. If it builds locally, it should build in GitHub Actions, Azure DevOps, or whatever pipeline you're using.

Cross-Platform Confidence: .NET 10 runs on Windows, macOS, and Linux. Testing on your target deployment platform (especially if it's Linux) catches filesystem case-sensitivity issues, path separator problems, and permission behaviors early.

Prerequisites and Hardware Recommendations

Minimum Requirements

Component	Windows	macOS	Linux
OS Version	Windows 10 v1607+ / Windows 11	macOS 14 (Sonoma) or 15 (Sequoia)	Ubuntu 22.04+, Fedora 42+, RHEL 9+
RAM	8GB (16GB recommended)	8GB (16GB recommended)	8GB (16GB recommended)
Storage	20GB free SSD space	20GB free SSD space	20GB free SSD space
Architecture	x64 or ARM64	Intel or Apple Silicon (M1+)	x64 or ARM64

← Scroll horizontally to view more →

Windows Setup

Install Visual Studio 2026 (Optional but Recommended)

Visual Studio remains the most feature-complete IDE for .NET development on Windows. The Community Edition is free for individuals, students, and open-source contributors.

Choose Your Installation Method

Manual DownloadRecommended

Download the installer directly from Microsoft and follow the guided setup wizard.

Download Visual Studio 2026

Command-Line Install

Install directly via Windows Package Manager (winget) - faster and scriptable.

winget install -e --id Microsoft.VisualStudio.Community

Need More Info?

Check out the winget package details for more information.

Select Required Workloads

During installation, select these workloads on the Workloads tab:

ASP.NET and web development - for Web APIs, MVC, and Blazor
.NET desktop development - includes console app support
Desktop development with C++ - enables native AOT compilation for faster startup

Version Note

At time of writing, Visual Studio 2026 (version 18.1.1) is the latest release. Visual Studio 2022 also works but may have UI differences.

First Launch Configuration:

Sign in with your Microsoft account (or create one here)
For Development Settings, choose Visual C#
Pick a color theme (Light recommended for accessibility)

Install VS Code

VS Code is lightweight, cross-platform, and increasingly popular among .NET developers.

Choose Your Installation Method

Manual DownloadRecommended

Download the installer directly from Microsoft and follow the guided setup wizard.

Download VS Code

Command-Line Install

Install directly via Windows Package Manager (winget) - faster and scriptable.

winget install -e --id Microsoft.VisualStudioCode

Need More Details?

Check out the winget package information.

Install the .NET 10 SDK

Choose Your Installation Method

Manual DownloadRecommended

Download the .NET 10 SDK installer directly from Microsoft's official site.

Download .NET 10 SDK

Command-Line Install

Install directly via Windows Package Manager (winget) - faster and scriptable.

winget install -e --id Microsoft.DotNet.SDK.Preview

For More Details

Visit the winget package page.

Verify installation:

dotnet --list-sdks

Expected output:

10.0.100 [C:\Program Files\dotnet\sdk]

Pro Tip: Multiple SDK Versions

You'll likely have multiple SDK versions installed over time. .NET 8 and .NET 9 are still supported. Install them side-by-side - global.json (covered later) controls which version your project uses.

Install Essential VS Code Extensions

Install these extensions for a productive C# development experience:

# Core C# development
code --install-extension ms-dotnettools.csdevkit
 
# Individual extensions (installed automatically with C# Dev Kit, but listed for reference)
code --install-extension ms-dotnettools.csharp
code --install-extension ms-dotnettools.vscodeintellicode-csharp
 
# Useful additions
code --install-extension tintoy.msbuild-project-tools
code --install-extension yzhang.markdown-all-in-one
code --install-extension humao.rest-client

Extension	Purpose
C# Dev Kit (ms-dotnettools.csdevkit)	Solution explorer, test discovery, project management
C# (ms-dotnettools.csharp)	Language support, IntelliSense, debugging via Roslyn
IntelliCode for C#	AI-assisted code completion
MSBuild project tools	IntelliSense for .csproj files
REST Client	Test HTTP APIs directly in VS Code

← Scroll horizontally to view more →

License Note

The C# Dev Kit has a more restrictive license than the base C# extension. Review the license terms.

Set Up WSL for Cross-Platform Development

If you're deploying to Linux servers (and most production .NET apps do), WSL (Windows Subsystem for Linux) is invaluable. It lets you run a genuine Linux kernel inside Windows.

# Install WSL with Ubuntu (run as Administrator)
wsl --install
 
# Restart your computer when prompted, then:
wsl --set-default-version 2

After restart, Ubuntu will launch automatically. Create your Linux username and password.

# Inside WSL, install .NET SDK
wget https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
rm packages-microsoft-prod.deb
 
sudo apt-get update
sudo apt-get install -y dotnet-sdk-10.0
 
# Verify
dotnet --version

Why WSL Matters

Testing on Linux locally catches platform-specific issues before they reach CI:

Linux is case-sensitive (Program.cs ≠ program.cs)
Path separators differ (/ vs \)
File permissions work differently
Symlink behavior varies

Catching these issues locally saves CI debugging time.

Common Windows Pitfalls

Problem	Cause	Fix
`dotnet` not recognized	PATH not updated	Restart terminal or run installer again
SDK installed but wrong version used	Multiple SDKs, no `global.json`	Add `global.json` to repo root
VS Code C# extension not loading	Extension conflict	Disable OmniSharp if C# Dev Kit installed
WSL file operations slow	Accessing Windows files from WSL	Work in `/home/user/` not `/mnt/c/`

← Scroll horizontally to view more →

macOS Setup

Install Xcode Command Line Tools

Required for various development tools:

xcode-select --install

Install VS Code

Choose Your Installation Method

HomebrewRecommended

Install via Homebrew package manager - simple and keeps VS Code up to date.

brew install --cask visual-studio-code

Manual Download

Download the installer directly if you prefer not to use Homebrew.

Download VS Code

Install the .NET 10 SDK

Choose Your Installation Method

HomebrewRecommended

Install via Homebrew package manager - handles dependencies automatically.

brew install dotnet@10

Manual Download

Download the official installer from Microsoft.

Download .NET 10 SDK

Verify installation:

dotnet --list-sdks

For Apple Silicon Macs (M1/M2/M3/M4), .NET 10 runs natively on ARM64—no Rosetta required.

Install VS Code Extensions

code --install-extension ms-dotnettools.csdevkit
code --install-extension ms-dotnettools.csharp
code --install-extension tintoy.msbuild-project-tools
code --install-extension humao.rest-client

Install JetBrains Rider (Alternative IDE)

Rider is a powerful cross-platform .NET IDE, free for non-commercial use since October 2024.

brew install --cask rider

Rider is popular among experienced .NET developers and offers excellent refactoring tools, though it occasionally shows false-positive errors in Razor files.

Common macOS Pitfalls

Problem	Cause	Fix
`dotnet` not found after install	Shell PATH not updated	Add to `~/.zshrc`: `export PATH="$PATH:/usr/local/share/dotnet"`
Certificate errors on HTTPS	Dev certs not trusted	Run `dotnet dev-certs https --trust`
Apple Silicon performance issues	Running x64 binaries via Rosetta	Ensure you downloaded ARM64 SDK
Visual Studio for Mac?	Reached end-of-life August 2024	Use VS Code, Rider, or VS in a VM

← Scroll horizontally to view more →

Important: Visual Studio for Mac Discontinued

Visual Studio for Mac is discontinued and doesn't support .NET 8+. Switch to VS Code or Rider.

Linux Setup

Install .NET 10 SDK

Ubuntu/Debian:

# Add Microsoft package repository
wget https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb
rm packages-microsoft-prod.deb
 
# Install SDK
sudo apt-get update
sudo apt-get install -y dotnet-sdk-10.0
 
# Verify
dotnet --list-sdks

Fedora:

sudo dnf install dotnet-sdk-10.0

RHEL/CentOS Stream:

sudo dnf install dotnet-sdk-10.0

Install VS Code

# Ubuntu/Debian
sudo apt-get install wget gpg
wget -qO- https://packages.microsoft.com/keys/microsoft.asc | gpg --dearmor > packages.microsoft.gpg
sudo install -D -o root -g root -m 644 packages.microsoft.gpg /etc/apt/keyrings/packages.microsoft.gpg
sudo sh -c 'echo "deb [arch=amd64,arm64,armhf signed-by=/etc/apt/keyrings/packages.microsoft.gpg] https://packages.microsoft.com/repos/code stable main" > /etc/apt/sources.list.d/vscode.list'
sudo apt update
sudo apt install code
 
# Fedora
sudo rpm --import https://packages.microsoft.com/keys/microsoft.asc
sudo sh -c 'echo -e "[code]\nname=Visual Studio Code\nbaseurl=https://packages.microsoft.com/yumrepos/vscode\nenabled=1\ngpgcheck=1\ngpgkey=https://packages.microsoft.com/keys/microsoft.asc" > /etc/yum.repos.d/vscode.repo'
sudo dnf install code

Install VS Code Extensions

code --install-extension ms-dotnettools.csdevkit
code --install-extension ms-dotnettools.csharp
code --install-extension tintoy.msbuild-project-tools

Common Linux Pitfalls

Problem	Cause	Fix
Permission denied on restore	NuGet cache permissions	`sudo chown -R $USER ~/.nuget`
ICU package missing	Globalization support	`sudo apt install libicu-dev`
OpenSSL version mismatch	Older distro	Install `libssl3` or use `--runtime linux-musl-x64`
Case-sensitivity bugs	Windows habits	Consistent file naming conventions

← Scroll horizontally to view more →

Verification - Confirm Your Environment Works

Run these commands on any OS to verify your setup:

# Check SDK version
dotnet --version
# Expected: 10.0.100 (or similar)
 
# Check all installed SDKs
dotnet --list-sdks
 
# Check installed runtimes
dotnet --list-runtimes
 
# Create and run a test project
mkdir ~/dotnet-test && cd ~/dotnet-test
dotnet new console -n HelloWorld
cd HelloWorld
dotnet run
# Expected output: Hello, World!
 
# Run a web project test
cd ~/dotnet-test
dotnet new webapi -n TestApi
cd TestApi
dotnet run
# Visit https://localhost:5001/weatherforecast in browser

VS Code Verification

Open VS Code in the HelloWorld folder: code .
Wait for C# Dev Kit to activate (see status bar)
Open Program.cs
Verify IntelliSense works: type Console. and see method suggestions
Set a breakpoint on line 1, press F5 to debug
Confirm breakpoint hits and variables are inspectable

Visual Studio Verification (Windows)

Open Visual Studio 2026
Create new project → Console App → .NET 10
Press F5 to build and run
Verify output appears in console window

Team Standardization

These configurations ensure every team member has an identical development experience.

Pin SDK Version with

global.json

Create this file in your repository root:

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

Options for rollForward:

disable - Exact version only
latestPatch - Allow 10.0.101, 10.0.102, etc.
latestFeature - Allow 10.1.x
latestMajor - Allow any newer SDK

Recommendation: Use latestPatch for stability with security updates.

Code Style with

.editorconfig

Create .editorconfig in your repository root:

# Top-most EditorConfig file
root = true
 
# All files
[*]
indent_style = space
indent_size = 4
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
 
# C# files
[*.cs]
# Organize usings
dotnet_sort_system_directives_first = true
dotnet_separate_import_directive_groups = false
 
# Use 'var' when type is apparent
csharp_style_var_for_built_in_types = false:suggestion
csharp_style_var_when_type_is_apparent = true:suggestion
csharp_style_var_elsewhere = false:suggestion
 
# Prefer expression-bodied members
csharp_style_expression_bodied_methods = when_on_single_line:suggestion
csharp_style_expression_bodied_properties = true:suggestion
 
# Naming conventions
dotnet_naming_rule.private_fields_should_be_camel_case.severity = suggestion
dotnet_naming_rule.private_fields_should_be_camel_case.symbols = private_fields
dotnet_naming_rule.private_fields_should_be_camel_case.style = camel_case_underscore
 
dotnet_naming_symbols.private_fields.applicable_kinds = field
dotnet_naming_symbols.private_fields.applicable_accessibilities = private
 
dotnet_naming_style.camel_case_underscore.required_prefix = _
dotnet_naming_style.camel_case_underscore.capitalization = camel_case
 
# New lines
csharp_new_line_before_open_brace = all
csharp_new_line_before_else = true
csharp_new_line_before_catch = true
csharp_new_line_before_finally = true
 
# JSON files
[*.json]
indent_size = 2
 
# YAML files
[*.{yml,yaml}]
indent_size = 2
 
# Markdown files
[*.md]
trim_trailing_whitespace = false
 
# Project files
[*.{csproj,props,targets}]
indent_size = 2

Code Analyzers

Add analyzers to your .csproj for consistent code quality:

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <Nullable>enable</Nullable>
    <ImplicitUsings>enable</ImplicitUsings>
    <AnalysisLevel>latest-all</AnalysisLevel>
    <EnforceCodeStyleInBuild>true</EnforceCodeStyleInBuild>
    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
  </PropertyGroup>
 
  <ItemGroup>
    <!-- Additional analyzers -->
    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.556">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
    <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="9.0.0">
      <PrivateAssets>all</PrivateAssets>
      <IncludeAssets>runtime; build; native; contentfiles; analyzers</IncludeAssets>
    </PackageReference>
  </ItemGroup>
</Project>

Tool Manifest for CLI Tools

Create a tool manifest for team-shared CLI tools:

# Initialize tool manifest (creates .config/dotnet-tools.json)
dotnet new tool-manifest
 
# Install common tools
dotnet tool install dotnet-ef
dotnet tool install dotnet-outdated-tool
dotnet tool install dotnet-format

This creates .config/dotnet-tools.json:

{
  "version": 1,
  "isRoot": true,
  "tools": {
    "dotnet-ef": {
      "version": "10.0.0",
      "commands": ["dotnet-ef"]
    },
    "dotnet-outdated-tool": {
      "version": "4.6.0",
      "commands": ["dotnet-outdated"]
    },
    "dotnet-format": {
      "version": "9.0.0",
      "commands": ["dotnet-format"]
    }
  }
}

New team members restore tools with:

dotnet tool restore

Git Hooks for Quality Gates

Use a .githooks folder with a pre-commit hook:

#!/bin/sh
# .githooks/pre-commit
 
echo "Running pre-commit checks..."
 
# Format check
dotnet format --verify-no-changes
if [ $? -ne 0 ]; then
    echo "❌ Code formatting issues found. Run 'dotnet format' to fix."
    exit 1
fi
 
# Build check
dotnet build --no-restore
if [ $? -ne 0 ]; then
    echo "❌ Build failed."
    exit 1
fi
 
# Test check
dotnet test --no-build --verbosity quiet
if [ $? -ne 0 ]; then
    echo "❌ Tests failed."
    exit 1
fi
 
echo "✅ All pre-commit checks passed."

Configure Git to use custom hooks folder:

git config core.hooksPath .githooks

VS Code Workspace Settings

Create .vscode/settings.json for consistent editor behavior:

{
  "editor.formatOnSave": true,
  "editor.defaultFormatter": "ms-dotnettools.csharp",
  "files.exclude": {
    "**/bin": true,
    "**/obj": true
  },
  "omnisharp.enableRoslynAnalyzers": true,
  "omnisharp.enableEditorConfigSupport": true,
  "dotnet.defaultSolution": "YourSolution.sln"
}

Quick Start Summary

New Machine Setup (5 Minutes)

Windows:

winget install Microsoft.VisualStudioCode
winget install Microsoft.DotNet.SDK.10
code --install-extension ms-dotnettools.csdevkit

macOS:

brew install --cask visual-studio-code
brew install dotnet@10
code --install-extension ms-dotnettools.csdevkit
dotnet dev-certs https --trust

Linux (Ubuntu):

wget https://packages.microsoft.com/config/ubuntu/24.04/packages-microsoft-prod.deb -O packages-microsoft-prod.deb
sudo dpkg -i packages-microsoft-prod.deb && rm packages-microsoft-prod.deb
sudo apt-get update && sudo apt-get install -y dotnet-sdk-10.0 code
code --install-extension ms-dotnettools.csdevkit

Cloning an Existing Project

git clone https://github.com/your-org/your-project.git
cd your-project
dotnet tool restore
dotnet restore
dotnet build
dotnet test

Troubleshooting FAQ

Q: "The SDK 'Microsoft.NET.Sdk' specified could not be found"

Cause: .NET SDK not installed or PATH not configured.

Fix:

# Verify SDK is installed
dotnet --list-sdks
 
# If empty, reinstall SDK
# If populated, restart your terminal/IDE

Q: "error CS0234: The type or namespace name 'X' does not exist"

Cause: Missing NuGet package or framework reference.

Fix:

dotnet restore
# If still failing, clear NuGet cache:
dotnet nuget locals all --clear
dotnet restore

Q: "The current .NET SDK does not support targeting .NET 10.0"

Cause: global.json specifies an SDK version you don't have.

Fix:

# Check required version
cat global.json
 
# Install that specific version, or update global.json

Q: VS Code IntelliSense not working

Cause: Extension conflict or OmniSharp vs C# Dev Kit conflict.

Fix:

Open VS Code settings
Disable omnisharp.useModernNet if using C# Dev Kit
Reload VS Code window (Ctrl+Shift+P → "Reload Window")

Q: "Unable to find package" during restore

Cause: Missing NuGet source or corporate proxy.

Fix:

# Check configured sources
dotnet nuget list source
 
# Add official source if missing
dotnet nuget add source https://api.nuget.org/v3/index.json -n nuget.org

Q: Certificate errors on localhost HTTPS

Cause: Development certificates not trusted.

Fix:

dotnet dev-certs https --clean
dotnet dev-certs https --trust

Q: WSL is extremely slow

Cause: Accessing Windows filesystem (/mnt/c/) from WSL.

Fix: Always work in Linux filesystem (/home/user/projects/). Clone repos directly in WSL, not on Windows drives.

Q: Rider shows false "Cannot resolve symbol" errors

Cause: Known Rider bug with Razor components and Unity plugin interference.

Fix: Build the project—if it compiles successfully, ignore the IDE errors. Check for Rider updates.

Final Checklist

Copy this checklist for new team members:

## .NET Development Environment Setup Checklist
 
### Installation
- [ ] .NET 10 SDK installed (`dotnet --version` returns 10.x.x)
- [ ] VS Code or Visual Studio 2026 installed
- [ ] C# Dev Kit extension installed (VS Code)
- [ ] Git installed and configured
 
### Project Setup
- [ ] Repository cloned
- [ ] `dotnet tool restore` completed
- [ ] `dotnet restore` completed
- [ ] `dotnet build` succeeds
- [ ] `dotnet test` passes
 
### Verification
- [ ] IntelliSense working in IDE
- [ ] Debugging works (breakpoints hit)
- [ ] HTTPS dev certificates trusted
 
### Team Standards
- [ ] `.editorconfig` rules understood
- [ ] Git hooks configured (`git config core.hooksPath .githooks`)
- [ ] Code formatting matches team style
 
### Optional (Windows)
- [ ] WSL2 installed for Linux testing
- [ ] .NET SDK installed inside WSL

Conclusion

A well-configured development environment is an investment that pays dividends throughout a project's lifecycle. By standardizing on specific SDK versions, enforcing code style through .editorconfig, and using tool manifests for CLI utilities, you eliminate entire categories of "works on my machine" problems.

Key Principles to Remember

Pin versions - Use global.json to ensure everyone uses the same SDK
Automate checks - Git hooks catch issues before they reach CI
Document everything - A checklist beats tribal knowledge
Test cross-platform - If deploying to Linux, test on Linux (even if it's WSL)

With this setup, your team can focus on building great software instead of debugging environment inconsistencies.

Last updated: January 2026 | .NET 10 SDK 10.0.1 | Visual Studio 2026 (18.1.1) | VS Code 1.104+