SkiaSharp 4.0 Reaches Stable with 24% Faster GPU Rendering and Animated WebP Support
SkiaSharp 4.148.0 is the first production-ready v4 release, delivering up to 24% faster GPU rendering, animated WebP encoding via SKWebpEncoder, a legacy-free API surface, and critical lifecycle fixes. Here is what changed since Preview 1 and how to migrate.
.NET MAUI Moves to CoreCLR: The End of the Mono Split
.NET 11 Preview 4 makes CoreCLR the default runtime for MAUI on Android, iOS, and Mac Catalyst, ending the long-standing Mono/CoreCLR split and bringing tiered JIT, PGO, full diagnostics, and a path to NativeAOT on mobile.
Escape Analysis in .NET 10: How the JIT Eliminates Heap Allocations Automatically
The .NET 10 JIT compiler can now prove that many objects never leave their parent method and allocate them on the stack instead of the heap, eliminating GC pressure without any code changes.
PostgreSQL as a Distributed Cache in .NET: One Database, Two Jobs
Microsoft's new Caching.Postgres package turns your existing PostgreSQL instance into a distributed cache. Combined with HybridCache, it delivers a tiered caching architecture without adding Redis to your infrastructure.
UnsafeAccessorAttribute: Zero-Overhead Private Member Access Without Reflection
UnsafeAccessorAttribute lets you access private fields, methods, and constructors at the same speed as direct calls — no reflection, no Reflection.Emit, and full Native AOT compatibility. Here's how to use it, when it makes sense, and where developers trip up.
Blazor's Virtualize Component Finally Handles Variable-Height Items in .NET 11
.NET 11 Preview 3 reworks the Virtualize component to measure actual item heights at runtime using a running average, eliminating the broken spacing and scroll jumps that plagued lists with variable-height content since the component shipped in .NET 5.
EF Core 11 Preview 3: Cheaper Change Tracking, Safer Migrations, and Cleaner SQL
EF Core 11 Preview 3 ships GetEntriesForState to bypass DetectChanges, ExcludeForeignKeyFromMigrations for cross-boundary relationships, migration tree divergence detection, and leaner join generation. It also bumps SqlClient to 7.0 and makes MigrationsNotFound throw by default.
.NET 11 JIT and Runtime Improvements: Free Performance You Didn't Ask For
.NET 11 Preview 3 ships JIT improvements that eliminate bounds checks, fold switch expressions into branchless code, and speed up casts -- plus VM-level wins like 200x faster interface dispatch on iOS and faster GUID generation on Linux. Here is what changed and why it matters.
System.Threading.Lock: The Purpose-Built Lock That Replaces Your object Hack
Since .NET 9, the System.Threading.Lock type gives you a dedicated, faster, and semantically clearer alternative to locking on a bare object. Here is how it works, why it is roughly 25% faster than Monitor, and what to watch out for when migrating.
System.IO.Pipelines: The High-Performance I/O API You're Still Not Using
System.IO.Pipelines is the API that powers Kestrel's legendary throughput, yet most .NET developers still reach for raw streams and byte arrays. Learn how PipeReader and PipeWriter eliminate the buffer-management nightmare and give you backpressure for free.
User-Defined Compound Assignment Operators: The C# 14 Feature That Kills Needless Allocations
C# 14 lets you define instance-level +=, -=, ++, and other compound assignment operators that mutate in place instead of allocating new objects. Here's how they work, when they fall back, and where the pitfalls hide.
SearchValues: The .NET Type That Turns Text Searching Into a SIMD Problem
SearchValues<T> analyses your search criteria once at creation time, then uses SIMD vectorisation and specialised algorithms to search spans at speeds most hand-written loops cannot match.
First-Class Span Types in C# 14: The End of Overload Sprawl
C# 14 promotes Span<T> and ReadOnlySpan<T> to first-class citizens with implicit conversions, smarter type inference, and new overload resolution rules that eliminate the need for duplicate API overloads across arrays and spans.
Mapperly: The Source-Generated Mapper That Makes AutoMapper Feel Like Legacy Code
Mapperly generates object mapping code at compile time using Roslyn source generators, delivering hand-written performance with zero reflection. Here is how to use it and why teams are switching.
Garnet: Microsoft's High-Performance Redis Alternative Built on .NET
Garnet is a Redis-compatible cache store from Microsoft Research that outperforms Redis at both low and high concurrency. Here's how to use it from your .NET applications.
HybridCache: The .NET Caching API That Should Have Existed Years Ago
HybridCache combines in-process and distributed caching behind a single API, with built-in stampede protection, tag-based invalidation, and zero-allocation reads for immutable types. Here is how to use it and why it replaces most hand-rolled IDistributedCache code.
Visual Studio 2026: The AI-Native IDE That Actually Earned the Title
Visual Studio 2026 shipped on March 31 with AI agents for profiling and debugging, Razor cohosting inside Roslyn, decoupled toolchains, and over 5,000 bug fixes. Here is what matters for .NET developers.
Collection Expression Arguments in C# 15: Passing Capacity, Comparers, and More with the with() Syntax
C# 15 adds the with() element to collection expressions, letting you pass constructor arguments like capacity and comparers directly inside the bracket syntax. Here is how it works, what it compiles to, and where it falls short.
The Copilot Profiler Agent in Visual Studio 2026: AI-Driven Performance Tuning That Actually Works
Visual Studio 2026's Copilot Profiler Agent combines AI with the built-in performance profiler to find bottlenecks, generate BenchmarkDotNet benchmarks, and suggest verified fixes — all from a natural language prompt.
Runtime Async in .NET 11: The End of Compiler-Generated State Machines
How .NET 11's runtime async moves async/await handling from the compiler into the runtime itself, delivering cleaner stack traces, better debugging, and reduced allocations without changing a line of your code.
Zstandard Compression in .NET 11: Faster Than Brotli, Built Into the Box
A practical guide to the new Zstandard compression APIs in .NET 11, covering streaming, one-shot, and dictionary-based compression alongside ASP.NET Core and HttpClient integration.
Running .NET in Web Workers: The New dotnet new webworker Template
How to use the new first-party Web Worker project template in .NET 11 Preview 2 to offload CPU-intensive work from the browser's main thread, keeping your Blazor WebAssembly UI responsive.
.NET 11 Preview 2: Runtime Async, Native OpenTelemetry, and AI-Ready EF Core
A practical walkthrough of the standout features in .NET 11 Preview 2, from runtime-native async and built-in OpenTelemetry tracing to vector search in EF Core and a resilient Kestrel parser.
.NET Runtime Configuration Knobs You Should Know
A guide to the most useful .NET runtime configuration settings for GC tuning, threading, diagnostics, and globalisation.
Making Your .NET Application Trim and AOT Ready
How to prepare your .NET application for IL trimming and Native AOT compilation, including common pitfalls and analysis tools.