Times shown in your selected time zone (America/Los_Angeles).
Change →
Day 1
Tuesday, November 10
Add Day 1 to calendar
8–9 AM
–
PST
+Add to calendar
Keynote
Scott Hanselman
Software development has never stood still. From Windows to the web, from building across platforms to the cloud, every new era has opened up new possibilities. And through it all, .NET has evolved alongside you, helping you bring your code, your apps, and your ideas forward.
Now, we're entering another defining moment. AI is changing not just what we build, but how we build it, opening up new ways to create, understand, modernize and operate applications.
Join Scott Hanselman and the .NET team as we explore what's new in .NET 11, see how .NET is evolving for the applications you have and the ones you'll build next, and discover how Copilot and agents are shaping the next era of development.
What's next isn't about starting over. It's about how far you can go from here.
9–10 AM
–
PST
+Add to calendar
What's new in C#
Mads Torgersen, Dustin Campbell
Union types are coming to C#! Unions model closed sets of data shapes, as commonly seen in e.g. wire protocols. Mads and Dustin explore the clean expression of intent and the confidence and elegance that unions lend to consuming code. We'll also take a look at other upcoming C# features, such as closed classes and extension indexers.
–
PST
+Add to calendar
Modern web development with ASP.NET Core & Blazor in .NET 11
Daniel Roth
ASP.NET Core and Blazor in .NET 11 deliver improvements across the web stack, driven by developer feedback and the demands of large-scale production services. In this demo-packed tour, we’ll see how .NET 11 strengthens the platform fundamentals with advances in performance, security, and observability; increases productivity across Minimal APIs, SignalR, and Blazor; and makes it easier to build distributed and agentic web applications. We’ll explore highlights including asynchronous validation, richer API contracts, more capable server-side rendering, scalable Blazor apps, deeper Aspire integration, and new building blocks for agentic user interfaces. Whether you build APIs, interactive web applications, or AI-enabled experiences, you’ll leave knowing how .NET 11 helps you build faster, more reliable, and more ambitious web applications.
10–11 AM
–
PST
+Add to calendar
Moving `dotnet` Ahead (of Time)!
Chet Husk
In .NET 11, the `dotnet` CLI is a native app - it's snappy, responsive, and flexible! It took a lot of work to get there, and we learned about some 'gotchas' along the way, so we want to show you our process so that you can make excellent NAOT apps too!
–
PST
+Add to calendar
Why WinForms must not change - yet reinvented itself with .NET 11!
Klaus Löffelmann
Some of the world's most important line-of-business applications are built on WinForms. They contain decades of domain knowledge, countless customer-specific workflows, and—in many cases—millions of lines of proven code. Rewriting them is rarely economical, and breaking their behavioral or designer compatibility is simply not an option. That is why WinForms must not change. But standing still would be just as dangerous. To remain the best platform for evolving these applications, WinForms must also reinvent itself as the migration tool that lets teams modernize without discarding their investment.
In .NET 11, that reinvention becomes visible. A new opt-in visual-styles generation gives controls modern metrics and appearance while preserving compatibility by default. Toggle switches, flash-reduced form startup, live Windows visual and accessibility settings, improved focus and text-scale handling, smoother batched UI updates, and new presentation capabilities help applications adopt today's Windows design language and accessibility expectations. The key is not to impose a disruptive new UI model, but to create deliberate conceptual seams inside existing applications: separating generated designer state from application logic, fixed layouts from adaptive layouts, synchronous UI mutation from responsive workflows, and irreplaceable business rules from replaceable presentation and infrastructure.
AI makes those seams actionable at a scale that manual modernization could never reach. The designer and runtime must give AI-supported development enough structure to understand a form, preserve its intent, and transform it safely. At the same time, WinForms applications need modern runtime foundations through which developers can add domain-specific copilots, intelligent workflows, and local or connected AI services without rebuilding the entire product. This session explores how .NET 11 turns compatibility from a constraint into a modernization strategy—and how WinForms can preserve decades of customer value while helping business applications become more adaptive, accessible, performant, and ready for the AI era.
11 AM–12 PM
–
PST
+Add to calendar
The .NET AI Stack: What's New, What's Next, and How It Fits Together
Luis Quintanilla
.NET developers have more AI building blocks than ever: model abstractions, data and retrieval, tools, agents, local inference, and the infrastructure that connects them. But how do these pieces fit together, and which ones should you reach for first?
In this session, we'll take a practical look at the evolving .NET AI stack: what's available today, the patterns emerging across the ecosystem, and where things may be heading next. Through a combination of examples and demos, we'll explore how the pieces can be composed into useful applications.
Whether you're just getting started or already building AI-powered software, you'll leave with a clearer mental model for navigating the .NET AI ecosystem and building what comes next.
–
PST
+Add to calendar
What’s New in .NET MAUI in .NET 11
Gerald Versluis
.NET MAUI in .NET 11 continues to improve the experience of building production-quality mobile and desktop applications from a single codebase. In this session, we’ll explore the latest improvements, including the move to CoreCLR, XAML source generation enabled by default, C# expressions in XAML, XAML Incremental Hot Reload, and Material 3 styling on Android.
We’ll also look at improvements to testing and the developer workflow, including how AI-assisted development fits into everyday .NET MAUI work. Join us for a practical tour of what’s new, what these changes mean for your existing applications, and how to take advantage of them in your next release.
12–1 PM
–
PST
+Add to calendar
C# Dev Kit 11: Faster Foundations for .NET Development—and What Comes Next
Drew Noakes, Emanuel Fernandez Dell'Oca
TBD
–
PST
+Add to calendar
More Processes, More Problems - how to speed up your builds with Multithreaded MSBuild
Chet Husk
Builds happen super frequently, so making this faster can have huge impact on your inner loops. Multithreaded builds can drastically speed up your workflow, and it's easy to try out! Learn how to try this new execution mode, what it means for your builds, and how to get future-proof your projects and tools to take advantage of it.
1–2 PM
–
PST
+Add to calendar
What's New in Aspire for .NET Developers
Maddy Montaquila, Damian Edwards
Last year, we told you that Aspire was for every developer - not just .NET developers. We've seen amazing adoption across all different languages, but of course, we have a special place in our heart for .NET. As we added new languages to Aspire, we challenged some of our early .NET-centric assumptions, and discovered a few ways to improve the experience we originally shipped. We're bringing some of these learnings back to the Aspire + .NET workflow, some which you can use today, and some coming very soon! Join Maddy and Damian from the Aspire team to learn how Aspire is better than ever for .NET developers - even if we changed the name 😉
–
PST
+Add to calendar
2 Secure 2 Curmudgeonly
Barry Dorrans
By popular demand (well, one person online), Barry returns with a summary of .NET's security bugs for 2025-2026, including things you, as a developer should do to avoid falling into the same deep pits.
2–3 PM
–
PST
+Add to calendar
Beyond Autocomplete: Getting the Most from GitHub Copilot for .NET
Wendy Breiding
GitHub Copilot has evolved far beyond code completion. In this practical session, discover the latest Copilot experiences for .NET developers and learn how to use them effectively across the development lifecycle—from understanding unfamiliar code and planning changes to implementing features, refactoring, and debugging issues.
Through real-world .NET examples, we’ll explore techniques for providing better context, crafting effective instructions, working with agentic capabilities, and keeping AI-generated changes accurate and maintainable. You’ll leave with repeatable workflows that help you spend less time on routine work and more time solving the problems that matter.
–
PST
+Add to calendar
.NET 11 Numerics
Tanner Gooding
.NET 11 expands the numerics toolbox with IEEE 754 decimal floating-point types, `BFloat16`, generic complex numbers, and new generic random-number APIs. It also brings performance and correctness improvements to `System.Numerics.Tensors`.
We'll explore how the new types fit into generic math, choose the right precision and range, and see how layout-aware tensor operations improve performance while handling shapes, overlapping memory, and special values consistently. Along the way, we'll cover rounding and practical parsing and formatting improvements.
We'll finish with a brief "and more is coming" look at .NET 12 tensor work, clearly distinguishing what's in .NET 11 from what comes next.
3–4 PM
–
PST
+Add to calendar
How Aspire uses .NET to build an agent-first toolchain for any programming language
Maddy Montaquila, Jose Perez Rodriguez
.NET is the backbone of a toolchain built for the next generation of software development - Aspire.
Join Jose, Aspire’s team lead, and Maddy, Aspire PM, to explore how the Aspire CLI, AppHost, Dashboard, and developer tooling come together to give agents a structured way to understand, run, debug, observe, and deploy distributed applications.
We’ll look at how Aspire brings together .NET technologies like Blazor, Native AOT, code generation, and more, to extend the development experience beyond .NET to languages like TypeScript, Python, and even Java. The result is a toolchain where .NET provides the orchestration, developer experience, and runtime foundation while developers and agents can work across the languages they're comfortable with for their apps.
Come see how Aspire is using .NET to build a toolchain where developers and agents can work together across any codebase!
–
PST
+Add to calendar
.NET Runtime vNext: Memory Safety and Runtime Async
Richard Lander, Andy Gocke
The .NET Runtime is the source of many performance and security improvements that make your apps better. Runtime Async and the updated memory safety model are among the biggest changes we've ever delivered. Runtime Async moves async orchestration and codegen from the Roslyn compiler to the RyuJIT JIT compiler, to enable better performance. Memory safety adds more strict compile-enforcement and improved auditability for unsafe code use. These changes will be critical for the next generation of apps that get written and deployed.
4–5 PM
–
PST
+Add to calendar
Post-Quantum Cryptography with .NET 11
Jeremy Barton
.NET 11 brings an expansion of the post-quantum cryptography capabilities. We will take a look at how the features can be used today and how we're preparing for the future.
–
PST
+Add to calendar
Bringing dotnet run, test, and watch to .NET MAUI
Jonathan Peppers
The .NET CLI is central to how developers build and test .NET applications, but mobile development has traditionally required separate tooling and IDE-specific workflows. In .NET 11, `dotnet run`, `dotnet test`, and `dotnet watch` work with .NET MAUI applications on devices, emulators, and simulators.
This talk covers what it took to bring these commands to Android and iOS. We will look at how the CLI selects a device, installs and launches an app, runs tests, captures results, and updates a running application when code changes. We will also examine the challenges that make mobile different from desktop, including platform tooling, application packaging, device communication, and process lifetime.
Along the way, we will use the commands with real .NET MAUI projects and discuss how they fit into local development, automated testing, and CI. Attendees will leave knowing how to build simpler, scriptable mobile workflows using the same CLI they already use elsewhere in .NET.
Day 2
Wednesday, November 11
Add Day 2 to calendar
8–9 AM
–
PST
+Add to calendar
Keynote
Mads Kristensen
A lot has changed in Visual Studio, and there’s much more on the way. Join us for a tour of the ideas, improvements, and new capabilities transforming how developers get things done. We’ll look at what’s possible today, explore how the developer experience is evolving, and peek around the corner at what’s coming next for Visual Studio.
9–10 AM
–
PST
+Add to calendar
The State of AI in Visual Studio
Rachel Kang
Visual Studio brings new brains and more choice to AI-assisted development. Explore a new agent harness powered by the Copilot SDK, expanded access to models and providers, and greater control over configuration and how AI works for you. See how GitHub Copilot and other AI options bring more capable agents, greater choice, and the flexibility to shape AI around every stage of your .NET development workflow.
–
PST
+Add to calendar
What's new in Visual Studio
Jason Chlus
Visual Studio keeps getting better for the work you do every day. Join us for a demo-packed tour of the latest features, productivity improvements, and tips and tricks for .NET developers. We'll explore smarter code navigation, a more customizable editor, better build and testing experiences, and new ways to work with Markdown and web files. Along the way, see how improvements driven by developer feedback make Visual Studio a great place to read, understand, review, and write code. From big additions to small quality-of-life wins, discover what's new and what you'll want to try next.
10–11 AM
–
PST
+Add to calendar
Get the most out of git in Visual Studio
Sebastian Hernandez
Explore how you can do your code generation, version control tasks, and Pull Request management all without having to leave the IDE with all of the new version control capabilities inside of Visual Studio.
–
PST
+Add to calendar
What’s New in Visual Studio Debugging and Diagnostics
Harshada Hole
Discover what’s new in Visual Studio debugging and profiling—from hands-free, AI-assisted debugging to seamlessly continuing your investigation in the IDE. Through practical demos, explore how the latest experiences help you uncover issues, understand performance, and confidently validate fixes.
11 AM–12 PM
–
PST
+Add to calendar
What's new in the MCP C# SDK
Stephen Halter
The Model Context Protocol is evolving, and the MCP C# SDK is evolving with it. In this session, we’ll explore what’s new in the SDK and the latest protocol revision, from building scalable servers with stateless requests to collecting user input across multiple interactions. See these features in action in a practical C# server, and learn how the SDK continues to support existing MCP clients as the protocol evolves.
–
PST
+Add to calendar
Building great Windows apps with WinUI and agents
Morten Nielsen, Niels Laute
Discover how WinUI and the latest .NET tooling make it easier than ever to build modern, high-performance Windows apps. See how new `dotnet new` templates simplify project creation, how `dotnet run` seamlessly handles package identity, and how capabilities like Native AOT help developers deliver fast, efficient apps. We'll explore how modern tooling makes it easier to build, run, debug, test, and package WinUI apps using your favorite development environment, including Visual Studio and VS Code. You'll also see how WinAppCLI and AI coding agents come together to streamline development workflows, automate repetitive tasks, and help developers build great Windows apps faster.
12–1 PM
–
PST
+Add to calendar
Building the future of agentic UI with Blazor
Daniel Roth
As AI agents move from answering questions to reasoning over context, using tools, and taking action, the needs of modern web UI are changing. Free-form chat remains a powerful and flexible foundation, but agentic applications must also communicate progress and tool activity, connect conversations to structured interfaces, synchronize shared state, request human decisions, and keep users in control. In this session, we’ll explore the emerging patterns shaping agentic UI and how .NET and the Microsoft stack support them. Through live demonstrations, see how the experimental Blazor AI components, the open AG-UI protocol, Microsoft Agent Framework, Microsoft Foundry, and Aspire work together to enable streaming interactions, custom tool experiences, human-in-the-loop workflows, and shared application state. Learn how these pieces fit together and what they mean for the next generation of web development with Blazor.
–
PST
+Add to calendar
CsWinRT 3.0: Modernizing the Windows Projections for .NET
Manodasan Wignarajah, Sergio Pedri
Learn what’s coming in CsWinRT 3.0, a major redesign of our WinRT projection support for .NET based on developer feedback.
1–2 PM
–
PST
+Add to calendar
GitHub Copilot modernization
Mika Dumont
This session covers how agentic modernization can accelerate a .NET upgrade. We'll walk through a real migration end to end, from assessing what will break before you start, through the upgrade itself, to getting a change your team will actually merge. Along the way we'll look at where the agent does the work for you, where it hands back to you, and how to extend it with your own skills when your codebase doesn't match the default path.
–
PST
+Add to calendar
Beyond Code Generation: Give AI Eyes and Hands for .NET MAUI
Gerald Versluis
AI can generate your XAML and C#, but can it tell whether the button is actually visible or the screen behaves as intended? Building mobile and desktop apps takes more than code generation. Your AI assistant needs eyes and hands on the running app.
In this demo-driven session, we'll explore how DevFlow and an interactive mobile canvas connect GitHub Copilot to a running .NET MAUI app. Starting with an existing application, we'll inspect the UI, give the assistant context about specific controls, interact with the app, and use logs and runtime information to investigate problems. We'll then make targeted code changes and replay user workflows to check the results.
Along the way, we'll see where MCP fits, what these experimental tools can and cannot do, and where developer judgment still matters. You'll leave with practical patterns for moving beyond generated code to an AI-assisted feedback loop for your own .NET MAUI apps.
2–3 PM
–
PST
+Add to calendar
No XAML Required: Native Windows Apps in Pure C#
Alexandre Zollinger Chohfi
What if a complete native Windows app were a single C# file - no .csproj, no App.xaml, no code-behind, no ViewModels?
Microsoft.UI.Reactor is an experimental C# framework that brings the MVU (Model-View-Update) pattern to WinUI 3. Your UI is a function of your state. State lives in hooks, next to the code that uses it. And every control on screen is a real WinUI control - the same runtime, the same controls, the same theming as the XAML app next door.
We'll start by running a complete Windows app with dotnet run app.cs, then build up: hooks and state, lists and keyed reconciliation, and the 60+ Roslyn analyzers that catch UI bugs while you type - because when your UI is ordinary C#, the entire .NET toolchain points straight at it.
This is an experiment, and the talk is honest about that: what works, what's rough, what we got wrong, and where XAML and MVVM fit alongside it (spoiler: they aren't going anywhere). Come for the live demo, leave with an opinion - we're actively collecting them.
–
PST
+Add to calendar
Azure's new lineup for .NET developers (Part 1)
Matt Soucoup, Paul Yuknewicz
Meet some of Azure's newest cast members for .NET developers. A Container Apps sandbox handles the code you'd rather keep at arm's length. AI Gateway keeps tabs on every model and tool your app calls, SRE Agent is the one who answers the pager at 2 AM, and Copilot canvases put Azure right in your developer workflow.. And... we're having them do all their own stunts, live on stream.
3–4 PM
–
PST
+Add to calendar
Azure's new lineup for .NET developers (Part 2)
Matt Soucoup, Paul Yuknewicz
Meet some of Azure's newest cast members for .NET developers. A Container Apps sandbox handles the code you'd rather keep at arm's length. Copilot canvases put Azure right in your editor. AI Gateway keeps tabs on every model and tool your app calls, and SRE Agent is the one who answers the pager at 2 AM. And... we're having them do all their own stunts, live on stream.
–
PST
+Add to calendar
C# File-based apps turned up to 11!
Damian Edwards
C# file-based apps are getting a serious upgrade in .NET 11.
In this session, we’ll tour the latest improvements, including faster launch performance, app-to-app references, richer package reference support, and expanded CLI support across more `dotnet` commands. We’ll see how file-based apps are growing from a lightweight way to run a single C# file into a surprisingly capable model for building real tools and applications—without giving up the simplicity that made them compelling in the first place.
If you’ve been curious how far C# can go without a project file, .NET 11 turns it up to 11!
4–5 PM
–
PST
+Add to calendar
.NET + Foundry: Better Together
Bruno Capuano
Microsoft Foundry keeps raising the bar for AI. What does that mean for your next C# app? Join this session for a demo-packed tour of the latest Foundry features and services, and discover how to get the most out of them with .NET. From powerful models to new AI capabilities, we’ll explore what’s new, what matters, and what’s worth bringing into your projects. Less slideware, more possibilities, and plenty of “I could use that!” moments.
–
PST
+Add to calendar
EF Core 11: Vector Search, Smarter LINQ, and a Friendlier dotnet ef
Jiri Cincura
EF Core 11 touches every layer of the stack. In this session we’ll tour the highlights: approximate vector search and full-text search on SQL Server, new LINQ operators like FullJoin and MaxBy/MinBy, and a query pipeline that produces noticeably leaner SQL. We’ll cover modeling upgrades for complex types and JSON, a far less ceremonious dotnet ef (config files, file-based apps, one-step migrations), bulk and batch support for Cosmos DB, and what to watch for when you upgrade.
Day 3
Thursday, November 12
Add Day 3 to calendar
8–9 AM
–
PST
+Add to calendar
Beyond the Agent Trace: Operating Foundry Agents with .NET Aspire
Shweta Iyer
Building and deploying an agent is only the beginning. When a request produces a slow, incorrect, or incomplete result, developers need visibility into both the agent’s execution and the application surrounding it.
In this session, I’ll share lessons from building a procurement agent in C#, deploying it as a Microsoft Foundry Hosted Agent in .NET, and adding telemetry and business audit records around its execution. We’ll compare the agent-centric traces available in Microsoft Foundry with the application-centric observability provided by .NET Aspire.
Using a sourcing workflow, we’ll follow a request through a .NET API, the hosted agent, its tools, supporting services, and the audit store. We’ll examine trace correlation, dependency failures, sensitive-data boundaries, and why telemetry and business auditing solve different problems. Attendees will leave with a practical patterns for developing and operating observable .NET agents.
–
PST
+Add to calendar
AI Journey with Telerik UI for Blazor: From Developer Productivity to Intelligent User Experiences
Maya Mateva
AI is transforming both how applications are built and how users interact with them. In this session, we'll explore the complete AI journey with Blazor, starting with Telerik MCP, AI skills, and intelligent tooling that accelerate development, simplify upgrades, and help developers stay productive throughout the application lifecycle. We'll then demonstrate how modern Blazor applications can deliver intelligent user experiences using AI-enabled UI components, WebMCP, Microsoft Agent Framework, AG-UI, and A2UI. You'll see how you can enable agent-ready applications where AI can assist developers during implementation and seamlessly collaborate with users through rich, dynamic, and adaptive interfaces.
9–10 AM
–
PST
+Add to calendar
Miniservices not Microservices in Azure
Shawn Wildermuth
For small and medium sized businesses, the complexity of setting up and maintaining Kubernetes cluster or even Container Services (ACS) is not necessary. In this talk, I'll introduce a middle ground of using Azure's databases, AppServices, Azure Functions and ServiceBus to build out simplified architecture without resorting to full-blown microservices.
–
PST
+Add to calendar
Build a .NET TUI in 30 Minutes
Isaac Levin
Command-line tools are quick to create, but they often become difficult to use once a workflow requires multiple inputs, validation, progress updates, and meaningful results. A terminal UI provides structure and guidance without the deployment, hosting, and maintenance overhead of a web application—making it a practical fit for developer tools, internal utilities, deployment helpers, and AI-assisted workflows.
In this live build, we’ll turn a basic .NET console app into a maintainable TUI. You’ll learn how to:
- Guide users with prompts, selections, and validation
- Display tables, panels, and progress feedback
- Separate presentation from application logic
- Test workflows without fragile terminal automation
- Use .NET Aspire integration for observability and diagnostics
You’ll leave with a reusable structure for building tools that are easier to operate, safer than ad hoc scripts, and simpler to support when something goes wrong.
10–11 AM
–
PST
+Add to calendar
Lessons from Blazor WASM in Production
James Hutchison
How does Blazor WASM work in production? We think pretty well, but not without issue. This talk is based on our experiences of converting a large, complex UI (180+ components) from ASP.net Webforms to Blazor. This talk covers:
- Does Blazor WASM live up to its original hype? Yes, but not quite how we envisaged.
- Our migration strategy from Webforms to Blazor WASM.
- Authentication and general architectural design.
- General issues, performance pitfalls and their solutions.
Hop on and get enthused about Blazor WASM.
–
PST
+Add to calendar
Building a multi agent solution using Aspire
Juergen Gutsch
In my spare time, I vibe-coded (actually, wise-coded) an application that runs multiple AI agents, controlled by a planning AI agent, to perform penetration tests on web applications.
It uses tools like Playwright and Aspire to optimize agentic development.
It's built with .NET and React, but uses alternative components to build and run the spare-time project faster and cheaper.
This session gives you an overview of how I built it and what it uses to run multiple agents for penetration testing.
11 AM–12 PM
–
PST
+Add to calendar
Taking Cake 7 to Eleven: Pipelines as Code with C# and .NET 11
Mattias Karlsson
Most CI/CD pipelines still live in vendor-specific YAML: powerful enough to get the job done, but often awkward to reuse, test, and debug. What if your pipeline were simply a C# program?
In this session, we will take Cake 7 all the way to eleven with the Cake SDK and .NET 11. Using familiar C# constructs, APIs, and tooling, we will build a real pipeline that runs consistently on a developer machine, in a container, and on hosted CI/CD platforms.
Along the way, you will see how pipelines written in C# can provide fast local feedback, proper debugging, reusable components, and testable build logic, without giving up integration with platforms such as GitHub Actions, Azure DevOps, or GitLab.
You will learn how to:
- Define build and release pipelines as strongly typed C# code
- Run and debug the same pipeline locally and in CI
- Structure pipeline logic for reuse, testing, and maintainability
- Keep your delivery process portable across platforms, clouds, and operating systems
By the end of the session, you will know how Cake 7 and .NET 11 can turn pipeline development up to eleven: less YAML, shorter feedback loops, and one pipeline that can build anywhere and deploy everywhere.
–
PST
+Add to calendar
Killing Session Theft: Device Bound Session Credentials using ASP.NET Core
Wesley Cabus
Infostealer malware doesn't need your password if it can steal your authentication cookie from disk or memory, and replay it on another machine. Any webserver happily accepts the stolen cookie since it was issued by the webserver itself. This type of attack bypasses WebAuthn or MFA entirely, since the cookie gets stolen after you have authenticated. Since there's no real fix against this, we can only issue cookies with a shorter lifetime to minimize the attack window.
Until now. Device Bound Session Credentials (DBSC) is a W3C draft introducing a solution, by tying the session cookie to the browser or device. The browser generates a private/public key pair, storing the private key ideally in secure storage like a TPM, while the webserver only issues short-lived authentication cookies. When the cookie expires, the browser can then only refresh the cookie by signing a server-issued challenge using that private device-specific key. While this doesn't prevent cookie and session theft, it does minimize the risk since cookies go stale faster and cannot be renewed without the device's private key.
During this session, I'll demonstrate how DBSC works by showing an example implementation in ASP.NET Core, adding the necessary endpoints to safely register and refresh DBSC-enabled session cookies.
12–1 PM
–
PST
+Add to calendar
Async Rx.NET
Ian Griffiths
Support for async/await in Rx.NET was first released in 2023, but has remained in preview since then, with very few changes. But this project is finally moving forward again. This session will show Async Rx.NET in action, and the work we are doing to make it ready for use.
–
PST
+Add to calendar
Silent Superpowers: Why Breaking Production Isn’t Scary Anymore
André Silva
Imagine unleashing new features into the wild without the fear of breaking things... Enter the world of feature flags. Picture this: your team ships code to production seamlessly, yet the power to unveil new functionalities remains entirely in your hands. This dynamic decoupling lets you test features live, roll them out gradually, and gather real-world feedback, all while mitigating risks and accelerating confident releases.
In the realm of applications, feature flag libraries weave effortlessly into your codebase, championing agile strategies like trunk-based development and dark launches. But why stop there? Step into the future with OpenFeature, an open-source, vendor-neutral standard that unifies feature flag management. With it, you wave goodbye to vendor lock-in and welcome streamlined experimentation across diverse environments.
Harnessing OpenFeature and vendor-neutral feature flags unlocks:
• Lightning-fast, risk-free deployments with hidden features until the perfect moment
• Precision targeting for canary releases, A/B tests, and tailored user experiences
• A harmonised, standardised approach to flag management across your tech ecosystem
Embrace this cutting-edge methodology to revolutionise your release process: achieve agility without sacrificing stability, and turn every deployment into an opportunity to innovate with confidence.
For this demo, I will be using Aspire with the flagd integration to showcase the potential of these two technologies together.
1–2 PM
–
PST
+Add to calendar
The Most Overengineered Pocketwatch Ever Made
Ed Charbeneau
This session is a retrospective on the engineering behind a pocket watch that runs a real-time voice agent. Built end to end in a single week with Claude Code, from product idea to working reality complete with its own product page, this project showcases an entirely agentic workflow for rapid prototyping and iterative development.
We'll explore the ESP32-S3 audio pipeline, including capture, echo cancellation, and the barge-in system that lets users interrupt mid-sentence, then follow the audio into Deepgram's Voice Agent API, where speech-to-text, LLM reasoning, and text-to-speech run as a single unified agent.
The device becomes actionable when we target it at Azure OpenAI, or at your own ASP.NET Core endpoint hosted in Azure, so the agent's reasoning, function calling, and business logic live in the .NET stack you already know while the device stays lightweight.
–
PST
+Add to calendar
Developer Workflows in AI Age - Local or Cloud 🧠🤖
Sam Basu
Generating code is easy, but building software takes knowledge and processes. While AI is dramatically changing how we build software, context and fundamentals matter – developers need all the guardrails to make Agentic workflows work the right way. There are lots of decision points:
- Run AI Models in the cloud or locally
- Balancing privacy & cost concerns
- Choices in Agentic harness
- IDE, Terminal or Browser workflows?
- Spec out project details or build ad hoc?
- Bridging the gap between Design & code
- Prescriptive guidance through Skills
- Delegate work with Sub-Agents
- Squad of Agents with varying responsibilities
- Pitching Agents against each other
- Bring grounded context with MCPs
- How to validate AI’s work?
- Human code reviews or architectural guidance?
Let’s have an honest conversation and see real-world AI-powered workflows. Modern development stacks should provide tooling to embrace Agentic workflows, irrespective of where developers are on the AI adoption spectrum. With contextual expertise to light up AI-human loops, the right guardrails can make developers ultra productive with AI – upwards and onwards.
2–3 PM
–
PST
+Add to calendar
Clean Architecture AND MORE with ASP.NET Core
Ardalis .
It's 2026 and Clean Architecture is still a relevant topic for software developers looking to write less tightly-coupled code. By understanding and applying a few principles, you can ensure your application remains loosely-coupled to infrastructure concerns. You'll see how in this session.
You'll ALSO see how to leverage the benefits of Vertical Slices in your architecture, which make it easier to ship new features and helps organize those features cohesively in your application.
Finally, you'll see how even with these two approaches, many applications can turn into a Big Ball of Mud because they lack modularity. You'll learn how using encapsulated module architecture can avoid this common architectural pitfall.
–
PST
+Add to calendar
How Do AI Systems Like ChatGPT Work? A Clear Explanation for Everyone!
Otto Dobretsberger
This session offers an accessible exploration of the inner workings of AI systems like ChatGPT, demystifying how these advanced language models generate human-like responses. We will break down the process of how large language models (LLMs) construct answers token by token, illustrating the step-by-step mechanics of language generation. Attendees will learn about the key components that drive these systems, including the role of training data, neural network architectures, and the probabilistic nature of response generation. We will also discuss how external factors, such as input prompts and fine-tuning, influence the model’s outputs, and explore the dependencies that shape their performance. Designed for a general audience, this talk avoids technical jargon while providing a clear, engaging look at the fascinating technology behind AI language systems, offering insights into their capabilities and limitations.
3–4 PM
–
PST
+Add to calendar
.NET AI Architecture and DevOps
Jeffrey Palermo
While it is useful and necessary to learn and use AI tools, .NET developers need to be able to integrate AI into existing software applications. This session will focus on the architecture implications of AI, where large language models fit into existing .NET applications, and how to integrate them into DevOps environments , including source control, builds, testing, and deployment- all powered by GitHub Copilot and Azure.
–
PST
+Add to calendar
Godot + C#15 and You!
Michael Hawker
Want to use the latest C# goodness like Unions and Indexer Extensions in Godot? Come find out how!
Just because Godot targets .NET 8 doesn't mean you can't use these features! We'll use PolySharp to easily access any of the latest syntactic sugar you want to use.
Find out how these new C# features can help you with your Godot game.
4–5 PM
–
PST
+Add to calendar
What NOT to AI: Hand-Crafting Your App’s Core Foundation
Michael Washington
While AI tools and workflows like "Vibe Coding" can rapidly generate applications, they often fall short when it comes to the core architecture of your software. In the Agentic Coding workflow, developers must transition from being typists to acting as strict architects. This session covers the critical code and infrastructure decisions you must handle manually and should never leave up to the AI. Learn how to define your application's foundation, including your database design, authentication mechanisms (like JWT vs. cookies), and Data Context structure. Finally, discover the importance of using dedicated tools—such as EF Core Power Tools—to update your data context reliably, ensuring your AI agents have a solid, well-defined blueprint to build upon.
–
PST
+Add to calendar
Your .NET MAUI App Works. Now Give It to a Real User.
Paul Usher
Building a .NET MAUI application is easy.
Building one that survives workshops, warehouses, field technicians, unreliable connectivity, large datasets, cameras, signatures, PDFs and users who absolutely will press that button twice is another matter entirely.
In this session, we'll look at lessons learned from building and deploying real-world .NET MAUI business applications across iOS and Android.
We'll explore practical patterns for responsive mobile UI, local data, offline workflows, asynchronous operations, device capabilities and interfaces that need to work equally well on phones and tablets.
We'll also look at what .NET 11 brings to the MAUI landscape, including the move to CoreCLR, and where that may change the way we think about performance and application architecture.
The examples come from production applications used in workshops and field-service environments, where network connectivity, hardware differences and unpredictable user behaviour are part of the specification whether we like it or not.
No Todo apps. No perfect Wi-Fi. Just production software and the lessons learned when it meets the real world.
Day 4
Friday, November 13
Add Day 4 to calendar
8–9 AM
–
PST
+Add to calendar
One Codebase, Two Worlds: Sharing Razor Components Across Blazor Web and .NET MAUI Hybrid
Shriram Sankaran
Teams with an existing Blazor web application are often asked to deliver the same functionality across mobile and desktop platforms without rebuilding the application from scratch. In this session, I will demonstrate how Razor components, services, UI patterns, and business logic can be shared between a Blazor web application and a .NET MAUI Blazor Hybrid app targeting Android, iOS, Windows, and macOS.
The live demonstration will show the same application running on the web and as a native hybrid application, with shared components such as data grids and charts. I will explain what can be reused directly, what requires platform-specific adaptation, and how to structure shared code using Razor Class Libraries and BlazorWebView.
The session will also explore the architectural decisions and code-sharing strategies needed to create maintainable experiences across web, mobile, and desktop environments. Attendees will leave with practical guidance for deciding what to share, what to abstract, and what to implement separately when extending a Blazor web application to mobile and desktop with .NET MAUI Hybrid.
–
PST
+Add to calendar
Building an AI-Powered Community Platform with Blazor, .NET MAUI, Aspire, and Azure AI Foundry
Augustine Correa
Bethuya is an AI-powered Community Platform built with Blazor, .NET MAUI, .NET Aspire, and Azure AI Foundry. Inspired by the challenges of running real-world developer communities, it introduces a Unified Participation Ledger that goes beyond attendance to capture volunteering, mentoring, speaking, organizing, and learning activities.
In this session, we'll explore how the modern .NET stack enables a single platform spanning web, mobile, distributed services, and AI-powered experiences. We'll cover architectural decisions, service orchestration with Aspire, cross-platform experiences with MAUI, role-aware interfaces with Blazor, and AI-enabled features powered by Azure AI Foundry.
Attendees will leave with practical guidance for building cloud-native, AI-powered applications with .NET and lessons learned from building a production community platform.
GitHub repo: https://github.com/HackerspaceMumbai/bethuya
9–10 AM
–
PST
+Add to calendar
Let’s catch up with C#!
Filip Ekberg
With every iteration of C#, we get more and more features that are meant to make our lives as developer a lot easier.
Let's explore some of the most interesting features in C# 9, 10, 11, 12, 13 and 14!
We will look at how the language has changed and why these changes to the language will make us better C# developers, with less bugs in our code.
We will cover features such as:
- Nullable reference types
- Pattern Matching in C# 8 => C# 14
- Record types
- Primary constructors
- Collection expressions
- Extension members
If you're working with C#, this is a session you do not want to miss!
–
PST
+Add to calendar
Eliminating Hidden Dangers to Your Applications: Patterns for Reliable Systems
Barry Stahl
There is a danger lurking in every system that hasn't taken explicit steps to eliminate it. This under-recognized data killer can cause inconsistencies in your system which can be as difficult to find as they are to correct. Fortunately, recognizing this monster is easy, and there are a number of great techniques you can use to keep it away for good.
In this talk, we will learn about the Dual-Writes anti-pattern: how to spot it, and what to do to avoid it. In doing so, we'll discuss several well-known patterns that when implemented in your microservices architecture, can help prevent the difficult errors often caused by dual-writes so you can spend more time at awesome conferences and less time supporting your applications. We'll review a number of examples in C#, including demonstrations using SQL Server, Cosmos DB and Kafka.
10–11 AM
–
PST
+Add to calendar
Building Dual-Screen Experiences with Avalonia
Javier Suárez
Dual-screen and foldable devices introduce more than just extra space. Applications need to adapt their layout while preserving state, focus and the user’s context as the available screen configuration changes.
In this session, we’ll explore how to build dual-screen experiences with Avalonia using TwoPaneView and the framework’s capabilities. Through several practical samples, we’ll look at common patterns such as list-detail interfaces, navigation experiences, editors and content that can move naturally between one and two panes.
We’ll demonstrate how these interfaces behave across different form factors, including iPhone Duo and other Android devices, and see how the same UI can adapt when running on a conventional desktop or single-screen device.
Along the way, we’ll cover pane placement, spanning and folding scenarios, responsive layouts, state preservation or manage the focus state.
You’ll leave with practical patterns and reusable techniques for building Avalonia applications that work naturally on both single-screen and dual-screen devices.
–
PST
+Add to calendar
Shipping a VS Code extension backed by a .NET Tool based analyzer
Erik Ejlskov Jensen
VS Code speaks TypeScript, but my T-SQL analysis rules are C# on top of DacFx. So how do you light up 140+ .NET analyzer rules as the developer types — no build step, nothing to manually install?
In this talk I'll show how I built the T-SQL Analyzer VS Code extension as a thin TypeScript front-end (with no previous TypeScript experience) over a long-lived .NET back-end: a persistent analyzer process, a simple stdin/stdout JSON protocol, and distribution as a NuGet tool run via dnx (so users just need the .NET 11 SDK).
I'll share the real lessons learned — so you can put a friendly editor experience on top of any .NET library you already own.
Takeaways
• Architect an editor extension as a thin UI over a reusable .NET engine
• Design a minimal, robust stdin/stdout JSON protocol
• Run and supervise a long-lived .NET server (spawn, crash recovery, shutdown)
• Distribute via NuGet + dnx for zero-install users
• Turn analysis results into live diagnostics with good error UX
11 AM–12 PM
–
PST
+Add to calendar
When Unit tests are not enough: Property-based testing and Snapshot tests
Davide Bellone
Unit Tests are all fun and games until they aren’t enough.
Integration Tests are better in many scenarios, but they aren’t always the best choice either.
What other kinds of tests do we have up our sleeves?
We can use Snapshot Tests to verify that we haven’t introduced regressions, and Property-based Tests to verify that invariants always hold.
Attendees will leave with a practical way to decide when to use example-based tests (such as Unit and Integration tests), Property-based Tests, Snapshots Tests, or a combination of all three, using xUnit, FsCheck, and Verify.
–
PST
+Add to calendar
ASP.NET Core 11 💖 OpenTelemetry
Martin Costello
ASP.NET Core 11 includes built-in support for OpenTelemetry metrics and traces which follow the OpenTelemetry Semantic Conventions for HTTP Servers.
But what are Semantic Conventions?
In this session we'll go into what the OpenTelemetry Semantic Conventions are and where ASP.NET Core 11 implements them.
Then we'll show how you can leverage them to validate your telemetry and generate consistent dashboards and alerts for polyglot services across your environment, no matter what programming languages they're written in.
12–1 PM
–
PST
+Add to calendar
Why not both? Bringing Modern Web Development to .NET
David Whitney
This talk is about the process of building three "what if" experiments that turned into a real projects to bring popular libraries, languages and tools to the .NET ecosystem.
- JsxCore - Native .NET bindings for ASP.NET MVC and React and JSX.
- AstroSharp - C# support for the popular Astro Static site builder
- TsxCore - a TypeScript compiler that targets MSIL and the CLR that compiles Typescript programs to native .NET
We'll cover how these seemingly impossible projects work, how they were designed, and why picking the best tool for the job sometimes takes you to really weird places.
A fun deep dive where you'll learn how to bridge seemingly incompatible platforms, build framework-like tools, and hopefully inspire you to make things you like play together. A talk about having your cake, and eating it.
–
PST
+Add to calendar
SE.Redis in .NET 11
Marc Gravell
Redis is a foundational piece of tech in many applications, and SE.Redis is the primary library for talking to Redis from .NET, either directly or via tools like asp.net caching, Hybrid Cache, Fusion Cache, etc.
Here we:
- have a quick look at new exciting features in SE.Redis like client-side-caching, active-active, etc for richer applications
- look at how SE.Redis 4.0 uses new C#/.NET features to create a new hyper-efficient API, while trivially supporting the pre-existing API
1–2 PM
–
PST
+Add to calendar
Beyond Prototypes: Building Production Ready AI Workflows
Cecil Phillip
Building a quick AI prototype in .NET is easier than ever, but architecting an AI-driven backend that can handle production workloads is a different story. Long-running prompts, rate-limited external APIs, and complex state management quickly turn simple intelligent apps into distributed systems challenges.
This session explores the idea of durable AI for modern systems. We'll look at building robust backends in C# that leverage libraries like Microsoft.Extensions.AI alongside Temporal's open source durable execution engine to orchestrate intelligent tasks reliably. We'll walk through code examples showing how to encapsulate LLM calls into resilient, stateful workflows that survive crashes, network issues, and API throttling, giving you a clear blueprint for production-ready AI.
–
PST
+Add to calendar
Meeple-Driven Design: Modeling Board Game Domains with C# 15 & .NET 11
Sarah Dutkiewicz
How do you model a game turn when a player can either roll dice, play a card, or pass without relying on vague string flags, null-heavy wrapper classes, or unsafe casting?
In this fast-paced 30-minute session, we’ll take a trip to the tabletop. We will use real-world board game mechanics - such as player turns, tile placement validations, and victory conditions - to explore the newest domain modeling capabilities in C# 15 and .NET 11.
You'll learn how native Discriminated Unions replace custom result wrappers, how Closed Hierarchies force exhaustive compile-time checking across game actions, how System.Text.Json handles complex union state out of the box, and how EF Core 11 indexes deeply nested complex types without schema friction. Walk away with cleaner, safer C# patterns you can apply directly to your software - no board game experience required!
2–3 PM
–
PST
+Add to calendar
Introducing BlazorKit
Shaun Walker
BlazorKit is a new open source project template for .NET 11 that allows you to build, extend, and deploy modern .NET web applications with the power of Blazor... but without the complexity of assembling everything from scratch. Utilizing an advanced template like BlazorKit dramatically reduces the amount of infrastructure developers need to create and maintain themselves. Rather than asking every project team to solve the same problems repeatedly, organizations can start with a proven foundation which enables them to spend more time building differentiated business functionality and less time creating application plumbing.
–
PST
+Add to calendar
Infrastructure as (Actual) Code with C# 15 and .NET 11
Cam Soper
Infrastructure as code usually means infrastructure as YAML, or a DSL that's almost a programming language. But if you already know C#, you already know how to build cloud infrastructure.
This session introduces infrastructure as code in plain C# using Pulumi's open source .NET SDK. We'll build and deploy real Azure infrastructure with the tools you already use every day, then put C# 15 and .NET 11 to work so the compiler catches infrastructure mistakes before they ever reach the cloud.
That matters more than ever now that AI agents are writing infrastructure code too. A rule written in an agent's instructions is a suggestion. A rule written in the type system is enforced, no matter who (or what) wrote the change.
3–4 PM
–
PST
+Add to calendar
IaC Forged in Code: Building Resilient Infrastructure with Modules
Mike Benkovich
How do you build a Shared Cloud Infrastructure that fits your needs and grows as your needs grow? In this session we look at Infrastructure as Code tools like Bicep and Terraform and explore how to design and implement a shared infrastructure pattern that is resilient, reusable, and maintainable. We'll cover module authoring, versioning, and distribution, as well as how to enforce naming conventions, tagging standards, and organizational policies through modules. Whether you're new to IaC or looking to improve your existing workflows, this session provides practical guidance for building a shared cloud infrastructure that works for your organization.
–
PST
+Add to calendar
Rethinking Microservices with Orleans
Ryan Karg
What if how you structure an application didn't have to dictate how you deploy it?
Traditional microservice architectures often treat architectural separation and physical distribution as the same problem. Orleans takes a different approach, allowing applications to be implemented as loosely coupled components while keeping deployment topology flexible.
In this session, we'll draw on our experience building game backends and other services with Orleans to explore how systems can evolve from a single process to multi-cluster and multi-region deployments without changing the underlying programming model. We'll discuss the realities of latency in globally distributed systems and along the way examine how Orleans can reduce communication costs, simplify operations, and challenge common assumptions about microservice design.
4–5 PM
–
PST
+Add to calendar
Building Oracle AI Apps with .NET and EF Core 11
Alex Keh
.NET 11 and Oracle AI Database 26ai introduce new features for AI development. We’ll explore EF Core 11 support for VECTOR_SEARCH(), vector indexes, and more. Discover how seamlessly the new Oracle AI Database Vector Store Connector integrates with native .NET vectors and Microsoft Agent Framework. Watch how Oracle Deep Data Security helps provide least-privilege access for agentic AI from .NET applications without any app code changes. See all these capabilities in action through demos.
–
PST
+Add to calendar
All in one E2E testing of ASP.NET Core web apps with UI/security/accessibility tests and more
Zoltán Lehóczky
Do you have an ASP.NET Core web app and make sure that it works? You can use the open-source UI Testing Toolbox to do all that: with the power of Selenium for browser UI tests, axe for checking accessibility, Zed Attack Proxy for security scans, and many more tools built in, it's a complete package. See all of this in action with plenty of (C#) code!