Friday, February 27, 2026

El Bruno introduces a .NET library that brings local CLIP image embeddings to your apps using ONNX Runtime, letting you experiment with multimodal search and image RAG without shipping data to the cloud. This post shows the model download scripts, a minimal C# example, and two runnable samples including an interactive Spectre.Console chat so you can get productive fast.

Denis Makarenko walks through Stripe integration options for ASP.NET Core, then implements a tidy server-side flow that creates a Checkout Session and verifies completion with just two minimal API endpoints. This post focuses on the why behind each choice and slips in practical tips like handling minor units, using idempotency keys, and surfacing the session ID for reliable redirects.

Ian Griffiths maps out how to run T4 templates on modern .NET by swapping Visual Studio's legacy engine for the TextTransformCore tool and wiring it into your build with Directory.Build files and a custom MSBuild target. Along the way this post unpacks assembly reference quirks, nesting with DependentUpon, and why teams like Rx.NET still lean on T4 instead of jumping to source generators.

Break down what XAML source generation is, how it works, and why it can improve performance, reliability, and your overall development experience. If you're building apps with .NET MAUI, Daniel Hindrikes offers something you don’t want to miss.

Mori shares a practical guide to function composition in C#, showing how composing small pure functions can turn imperative spaghetti into readable, testable pipelines. This post focuses on real-world refactors like order processing and data flows, explaining the mental model and patterns that make modern C# code easier to reason about and optimize.

Microsoft MVP Gulam Ali H. pulls back the curtain on what arrays really are in C#, from their heap memory layout and reference semantics to the performance cost of bounds checks. By tying arrays to List, Span, strings, and pooling, this post shows how GC behavior and memory patterns quietly shape correctness and speed across your .NET apps.

Nick Cosentino breaks down how Needlr auto-discovers and registers concrete classes and their interfaces in .NET, trimming boilerplate and preventing those sneaky DI runtime errors. This post explains what gets picked up, how lifetimes and exclusions work, and where source generation or reflection fits so you keep convention and manual control in balance.

Joseph Albahari rolls out LINQPad 9, a unified Windows and macOS release with C# 14 support, a redesigned UI, and a smart AI coding agent that can refactor code, write tests, and convert SQL to LINQ. This post highlights how the new provider model, faster editor and SQL tooling, and file-based app support can speed up everyday prototyping and database work across .NET 6-10.

Sam Basu previews the Uno Platform 6.5 community standup, highlighting why these upgrades matter for building real world cross platform .NET apps. This post zeroes in on productivity boosts like Studio's agent-first AI via Antigravity MCP, a default Hot Design visual loop, and a new scope selector, plus core improvements such as Unicode TextBox input, sturdier WebView2, broader Wasm drag and drop, and sharper diagnostics that make C# and XAML work feel smoother.

Vivek Baliyan revisits the Dapper vs EF Core default and shows why the once clear performance win is no longer the deciding factor. This post highlights how EF Core's productivity and evolving features can speed teams up in real apps, with pragmatic notes on when a micro ORM still makes sense.

Jonathan J. Tower talks with Matthew Soucoup about GitHub Copilot's App Modernization agent for .NET, unpacking how it assesses legacy codebases, plans upgrades, and executes tasks with persistent memory to keep teams moving. If you are wrangling aging .NET Framework or multi-version apps, this podcast shows how AI can de-risk migrations to modern .NET and the cloud while complementing helpers like Web Forms to Blazor tooling.

Claudio Bernasconi makes the case for upgrading Blazor apps to .NET 10, not just because it is LTS but for the practical gains it brings. This post highlights smaller payloads for faster startup, a PersistentState attribute that tames prerendering on Blazor Server, new JS interop that can construct JS objects, and NavigationManager.NotFound for consistent 404s across render modes. The focus is on what real apps get in return: quicker loads, less glue code and more correct behavior.