TL;DR — .NET 10 (LTS) shipped on November 11, 2025, alongside Visual Studio 2026 and big updates across ASP.NET Core, EF Core, .NET MAUI, and AI tooling. Expect faster apps, cleaner language features in C# 14, first‑class agent frameworks, and practical improvements you’ll use on day one.

The big picture

Microsoft officially released .NET 10 (Long‑Term Support) at .NET Conf 2025, with three years of support through November 2028. VS2026 also reached GA, bringing performance, UX, and AI‑native capabilities. Download links and sessions are live.

• .NET 10 = LTS (3 years of support). Microsoft recommends production upgrades to benefit from performance, security, and new capabilities.
• Visual Studio 2026 GA delivers a redesigned Fluent UI, major performance wins (UI hangs cut by ~50%), and deeper GitHub Copilot integration.

Performance: the fastest .NET yet

If you care about throughput and latency, this is the headline. The runtime and JIT received broad optimizations, with hardware acceleration where available.

• JIT & runtime: better inlining, method devirtualization, loop inversion, improved struct argument codegen, and more stack allocations.
• Hardware acceleration: AVX10.2 on modern Intel and Arm64 SVE paths, plus GC write‑barrier improvements reducing pause times.
• NativeAOT: smaller, faster ahead‑of‑time binaries—useful for microservices and CLI tools.

See Stephen Toub’s deep dive for dozens of concrete micro‑optimizations across collections, JSON, regex, GC, networking, and more.

C# 14: everyday quality‑of‑life wins

C# 14 lands with features that simplify real code—properties, spans, lambdas, and extension members.

Highlights:

• Extension members (methods, properties, operators) with the new extension block syntax—cleaner than this‑parameter methods and supports static extensions.
• Field‑backed properties, null‑conditional assignment ?.=, modifiers on simple lambda parameters, and implicit Span<T> conversions for cleaner, faster code.

Example — an extension property you’ll actually use:

public static class EnumerableExtensions
{
    extension<T>(IEnumerable<T> source)
    {
        public bool IsEmpty => !source.Any();
    }

Called as items.IsEmpty without changing the original type.

Upgrading to C# 14? Review compiler breaking changes (span conversions, lambda modifiers) to avoid surprises during overload resolution

ASP.NET Core 10: better Blazor & modern web primitives

ASP.NET Core 10 focuses on practical improvements that reduce friction in Blazor apps and tighten developer ergonomics.

• Blazor static asset handling: the Blazor script is now a static web asset with automatic compression and fingerprinting—simpler caching and CDNs.
• Navigation & routes: NavigateTo no longer scrolls to top on same‑page nav; route templates get syntax highlighting in tooling.
  
• Docs & overview call out additional improvements: WebAssembly preloading, memory pool eviction, improved validation & diagnostics, and passkeys support in Identity.

Example — conditional row styling with QuickGrid:

<QuickGrid Items="items" RowClass="GetRowCssClass">
    ...
</QuickGrid>

@code {
    private string GetRowCssClass(MyItem item) 
        => item.IsArchived ? "row-archived" : null;
}

Simple UI polish that ships with updated samples.

EF Core 10: AI‑ready data (vectors & JSON)

EF Core 10 adds vector and JSON types support (Azure SQL & SQL Server 2025), making semantic search and RAG patterns a first‑class experience.

Example — similarity search with embeddings:

public class Blog
{
    [Column(TypeName = "vector(1536)")]
    public SqlVector<float> Embedding { get; set; }
}

// Store embedding
context.Blogs.Add(new Blog { Name = "Some blog", Embedding = new SqlVector<float>(embedding) });
await context.SaveChangesAsync();

// Query by similarity
var top = await context.Blogs
    .OrderBy(b => EF.Functions.VectorDistance("cosine", b.Embedding, queryVector))
    .Take(3)
    .ToListAsync();

This is production‑grade vector work with LINQ—no custom SQL required.

.NET MAUI in .NET 10: quality & Aspire integration

The MAUI team prioritized stability and modernization. New project templates integrate .NET Aspire service defaults for telemetry and service discovery, with sensible OpenTelemetry wiring out‑of‑the‑box. Control and platform fixes landed across iOS/Android as part of the release cycle.

• Aspire service defaults: builder.AddServiceDefaults() configures tracing, metrics, service discovery, and HttpClient behavior—no boilerplate.
• Controls & behaviors: updated selection events and web request interception in hybrid scenarios, plus ongoing stabilization work.

AI: agents, MCP, and model optimization

Beyond language/runtime, .NET 10 leans into AI‑first development with building blocks for intelligent apps and agent workflows.

• Microsoft Agent Framework for .NET (public preview): build agents with orchestrations (sequential, concurrent, handoff, group chat), tools via functions/MCP, DI middleware, and built‑in observability.
• MCP C# SDK (public preview): extend agents with external tools/services using a common protocol.
  
• ONNX Runtime + Olive: optimize and run models efficiently across CPU/GPU/NPU (including Copilot+ PCs with Snapdragon NPUs) for local‑first experiences; Olive automates quantization/optimization.

If you’re building edge or hybrid AI, start with ONNX Runtime execution providers and use Olive CLI to auto‑optimize SLMs with latency/accuracy constraints.

Visual Studio 2026: AI‑native, faster, and refined

VS2026 is an AI‑native IDE with Copilot woven into debugging, profiling, and modernization workflows—and it’s just faster. Early adopters reported massive solution load improvements; Microsoft claims UI hangs down by ~50%.

• Profiler Agent & AI diagnostics help spot perf issues faster; updated Razor tooling and hot reload polish day‑to‑day ergonomics.
• Design & UX: Fluent UI refresh, 11 new themes, and responsive UI under load.

Upgrading: a pragmatic checklist (tested)

1) Confirm support & install tooling

• Install .NET SDK 10.0.100 (GA) and VS2026 GA or use VS Code + C# Dev Kit.
• Review breaking changes for ASP.NET Core, libraries, and C# to pre‑empt compile/runtime differences.

2) Update target frameworks

• Bump TargetFramework to net10.0 across solutions; retarget workloads (Web, MAUI, etc.) as needed. Use the compatibility docs while refactoring.

3) Validate performance & AOT

• Re‑measure hot paths; consider NativeAOT for CLI/microservices (watch trimming warnings; zero‑warning builds behave identically post‑AOT).

4) Adopt C# 14 features incrementally

• Introduce extension members in helper libraries; switch hot call‑sites to span‑based APIs where beneficial; check overload resolution with spans.

5) Modernize data & AI

• If you’re doing RAG/semantic search, migrate to EF Core 10 vector/JSON types on Azure SQL/SQL Server 2025. Wire Agent Framework/MCP where agents make sense.

A few “show me” demos you can try today

A) Passkeys with ASP.NET Core Identity

Adopt passkey/WebAuthn for passwordless auth; the docs list Identity enhancements and OpenAPI/minimal API refinements for .NET 10.

• Enable Web Authentication API (WebAuthn) passkeys
• Implement passkeys in ASP.NET Core Blazor Web Apps

B) AOT console utility

• Publish a small console tool with NativeAOT for instant startup and tiny footprint—especially useful for devops helpers.

Microsoft.AspNetCore.OpenApi added to the ASP.NET Core web API (Native AOT) template

C) Agent + MCP integration

• Create a .NET Agent that calls internal tools via MCP; host it alongside your web API using familiar DI/middleware patterns.

Why this release matters

Between runtime speedups, C# 14 expressiveness, web & MAUI steady improvements, and AI/agents becoming first‑class citizens, .NET 10 feels like a pragmatic step forward rather than just a feature drop. You can adopt most changes incrementally and get gains quickly—especially in performance and developer ergonomics.