Migrating a Synology NAS to a UniFi UNAS Pro 8 with Robocopy, SMB Multichannel, and Surprising Performance Traps
<div><p>I’ve had a <a href="/blog/synology-ds1520-is-the-sweet-spot-for-a-home-nas-and-a-private-cloud">Synology NAS</a> for a <a href="/blog/a-basic-noncloudbased-personal-backup-strategy">very long time</a>, and recently I started moving its contents to a new <a href="https://store.ui.com/us/en/category/network-storage">Ubiquiti UniFi UNAS Pro 8</a>. This seemed like it ought to be a fairly boring operation. Both devices speak SMB, I have a fast network (recently upgraded to 10 gigabit internally), and Windows has had tools for copying files reliably between machines for decades. Naturally, it turned into a whole evening of learning things I thought I already knew, which is why I started a blog lol.</p> <p>There was a nice bit of history here for me because back in 2007 (good lord!) I wrote a post called <strong>“<a href="/blog/xcopy-considered-harmful-robocopy-or-xxcopy-or-syncback">XCopy considered harmful - Robocopy or XXCopy or SyncBack</a>.”</strong> My argument at the time was basically that once you are moving enough files, Explorer stops being the move and Robocopy starts looking pretty good. I even used <code>/Z</code>, Robocopy’s restartable mode, because being able to resume a partially transferred file was useful on unreliable connections.</p> <p>Almost twenty years later, <code>/Z</code> turned out to be one of the most important things I needed to remove because it made everything hella slow.</p> <h4>The migration</h4> <p>The basic job was straightforward. I had shares on the Synology such as:</p> <pre><code>\\server\music </code></pre> <p>and matching shares on the UNAS:</p> <pre><code>\\UNAS-Pro-8\music </code></pre> <p>I initially used Explorer, mostly because it was there and because sometimes the easy thing really is the easy thing. That lasted until Explorer started producing errors on individual files:</p> <pre><code>The requested operation could not be completed due to a file system limitation </code></pre> <p>My first thought was filenames. NAS migrations are full of opportunities to discover that one filesystem is more permissive than another, and there were filenames with parentheses and other punctuation in them.</p> <p>Then this failed:</p> <pre><code>\\server\music\Athlete\Tourist\05 Wires.m4p </code></pre> <p>There is nothing especially exotic about <code>05 Wires.m4p</code>, so I moved over to Robocopy to get a little more information. It consistently got to 92% and returned Windows error 665:</p> <pre><code>92% New File 4.3 m 05 Wires.m4p ERROR 665 (0x00000299) Copying File The requested operation could not be completed due to a file system limitation </code></pre> <p>At this point the useful question was no longer “what is wrong with that filename?” but “which part of the path is refusing this file?”</p> <p>I copied the file from the Synology to my local Windows desktop. That worked. I then copied the local file from Windows to the UNAS, and that failed with the same filesystem limitation.</p> <p>That isolated the problem so the Synology could read the file, Windows could store it, and something about writing this particular file to the UNAS was causing trouble.</p> <h4>Alternate Data Streams, again</h4> <p>NTFS files can contain named Alternate Data Streams in addition to the ordinary unnamed stream that we usually think of as the contents of a file. This is an old Windows filesystem feature, and <a href="/blog/removing-security-from-downloaded-powershell-scripts-with-alternative-data-streams">it happens to be one I wrote about in 2007</a> when discussing <code>Zone.Identifier</code>, which Windows can use to record where a downloaded file came from. I even <a href="/blog/emancipation">blogged about Alternate Data Streams in 2003</a>!!! Windows can expose these streams with <code>DIR /R</code>.</p> <p>So I ran:</p> <pre><code>dir /r "%USERPROFILE%\Desktop\05 Wires.m4p" </code></pre> <p>and got:</p> <pre><code>11/30/2011 02:17 PM 4,576,368 05 Wires.m4p 360,456 05 Wires.m4p:01APIC_03.jpg:$DATA </code></pre> <p>There it is. Alongside the normal 4.5 MB music file was a roughly 360 KB named data stream called <code>01APIC_03.jpg</code>.</p> <p>That also explained the strange 92% failure. Robocopy was successfully getting through the main contents of the file and then encountering the additional stream. What had looked like a failure somewhere in the middle of an ordinary <code>.m4p</code> file was actually occurring when Windows attempted to deal with the additional filesystem data.</p> <p>Robocopy has support for exactly this situation. Microsoft documents <code>X</code> as one of the <code>/COPY</code> flags, meaning “skip alternate data streams.” So:</p> <pre><code>/COPY:DATX </code></pre> <p>means copy the file’s data, attributes, and timestamps, but do not copy the alternate streams. <code>/DCOPY:DATX</code> applies the corresponding behavior to directories. I retried the same file:</p> <pre><code>robocopy "\\server\music\Athlete\Tourist" "\\UNAS-Pro-8\music\Athlete\Tourist" "05 Wires.m4p" /R:0 /W:0 /COPY:DATX /DCOPY:DATX /V </code></pre> <p>and it completed successfully. The important distinction here is that <code>DATX</code> does not remove metadata stored <em>inside</em> an MP3, M4A, M4P, JPEG, or other file format. It tells Robocopy not to reproduce separate filesystem streams associated with the file. In my case those extra streams were not something I needed to preserve on the new NAS.</p> <h4>The copy worked, but it was slow</h4> <p>Once the ADS issue was understood, I started the larger migration with a fairly conventional-looking Robocopy command:</p> <pre><code>robocopy "\\server\music" "\\UNAS-Pro-8\music" /E /Z /MT:16 /R:2 /W:2 /COPY:DATX /DCOPY:DATX /XJ /TEE /LOG:"%USERPROFILE%\Desktop\synology-to-unas.log" </code></pre> <p>It ran, but performance was all over the place. Sometimes I would see a few hundred megabits per second, then it would drop dramatically. A small file could appear to sit there for a long time. I started wondering whether I was looking at buffering, slow disks, parity calculations, SMB behavior on the UNAS, or maybe my Synology had finally reached its limits.</p> <p>So now it's "just try random stuff (bisect)" time. I reduced the number of threads. I tried single threaded. None of that helped. Then I removed <code>/Z</code>.</p> <p>Microsoft’s Robocopy documentation describes <code>/Z</code> as restartable mode, which lets an interrupted file resume rather than starting again from byte zero. What I had forgotten is that Microsoft’s current migration guidance specifically warns that <code>/Z</code> should be used cautiously because the extra logging required for restartability can significantly reduce copy performance.</p> <p>My successful music run ended up using:</p> <pre><code>robocopy "\\server\music" "\\UNAS-Pro-8\music" /E /MT:4 /R:2 /W:2 /COPY:DATX /DCOPY:DATX /XJ /TEE /LOG:"%USERPROFILE%\Desktop\synology-to-unas-DATX.log" </code></pre> <p>The summary from that run was:</p> <pre><code> Total Copied Skipped Mismatch FAILED Files : 15940 6991 8949 0 0 Bytes : 70.907 g 47.917 g 22.989 g 0 0 Speed : 187,185,171 Bytes/sec. </code></pre> <p>So the run that copied almost 48 GB of remaining data averaged about 187 MB/sec, with no failed files.</p> <p>This was not a controlled benchmark where I changed exactly one variable while everything else remained identical, so I’m not going to pretend the number proves that <code>/Z</code> accounted for every bit of the earlier slowdown. The practical difference was large enough, however, that <code>/Z</code> is no longer something I will automatically put in a LAN migration command just because restartability sounds desirable. On a stable local network I would start without it and add it only when I actually need its semantics.</p> <h4><code>/MT</code> is useful, but it helps a particular kind of problem</h4> <p>Robocopy’s <code>/MT:n</code> option runs copies using multiple threads. It supports values from 1 through 128, with eight threads as the default if <code>/MT</code> is supplied without a number. Microsoft’s own migration guidance also points out that more threads do not automatically translate into a faster migration and recommends measuring thread counts against the actual workload.</p> <p>This made more sense once I stopped thinking of <code>/MT:4</code> as “make one file four times faster.”</p> <p>Imagine a music collection with thousands of files of questionable provenance (I ripped them, just kidding). There is work associated with opening a file, creating the destination file, reading and writing its contents, dealing with metadata, and closing it again. A single-threaded copy has periods where the network or storage can be waiting while one of those operations completes. Having several files in progress at once gives Robocopy opportunities to overlap that work.</p> <p>For this particular collection, four threads turned out to be a good fit. Sixteen wasn’t obviously helping more, and one thread wasn’t an improvement. I would resist turning <code>/MT</code> into a magic value that belongs in every command line, because a directory containing 50,000 photographs presents a different workload from four 900 GB disk images.</p> <p>There is also a logging cost worth remembering. Microsoft recommends redirecting Robocopy output to a log when using multithreaded copies, and its migration guidance uses switches such as <code>/NP</code>, <code>/NFL</code>, and <code>/NDL</code> when the objective is throughput rather than watching every filename scroll by.</p> <p>For a migration I am not actively watching, I would probably use something like:</p> <pre><code>robocopy "\\server\share" "\\UNAS-Pro-8\share" /E /MT:4 /R:2 /W:2 /COPY:DATX /DCOPY:DATX /XJ /NP /NFL /NDL /LOG:"%USERPROFILE%\Desktop\nas-migration.log" </code></pre> <h4>Then came the large files</h4> <p>Later I started copying some files that were hundreds of gigabytes each. Microsoft describes <code>/J</code> as unbuffered I/O and recommends it for large files, so it seemed like the obvious option to try.</p> <p>With <code>/J</code> enabled, however, NAS-to-NAS transfer slowed dramatically. The useful thing about having a Windows machine in the middle is that I could test each half of the trip separately. I took one of the exact same large files and copied it directly from the Synology to my local machine. That ran at roughly 250 MB/sec, so the Synology was perfectly capable of reading the file at high speed.</p> <p>I then removed <code>/J</code> from the direct Synology-to-UNAS Robocopy command:</p> <pre><code>robocopy "\\server\share" "\\UNAS-Pro-8\share" "huge-file.ext" /R:0 /W:0 /COPY:DATX /NP </code></pre> <p>and the speed came back.</p> <p>I don’t think the useful conclusion is that <code>/J</code> is bad. Microsoft recommends it for large-file copies for a reason, and it is entirely possible that it is exactly what you want when copying from local disk to local disk or in another network configuration. What mattered here was that Windows was simultaneously reading from one SMB server and writing to another SMB server, and on this particular path buffered I/O performed much better.</p> <p>That is a good reminder that command-line switches describe behavior, not guaranteed performance improvements. <code>/J</code> changes the I/O model. <code>/MT</code> changes concurrency. <code>/Z</code> adds restartability. Whether those changes improve a migration depends on the rest of the system.</p> <h4>The Synology was faster than I gave it credit for</h4> <p>At several points I blamed the aging Synology. It is an old machine with spinning disks, so it was easy to assume that a few hundred megabits per second was simply all it had left. Then I remembered that the Synology has four 1 GbE interfaces and that SMB 3 supports Multichannel. I am still surprised this worked so well.</p> <p>SMB Multichannel allows an SMB session to use multiple network paths simultaneously. Microsoft documents this specifically as a way to aggregate available network bandwidth, and Synology supports SMB3 Multichannel for the same reason.</p> <p>Windows makes the active channels easy to inspect:</p> <pre><code>Get-SmbMultichannelConnection -ServerName server | Format-Table ServerName,Selected,ClientIpAddress,ServerIpAddress,ClientLinkSpeed,ServerLinkSpeed,CurrentChannels </code></pre> <p>My machine reported:</p> <pre><code>ServerName Selected ClientIpAddress ServerIpAddress ClientLinkSpeed ServerLinkSpeed ---------- -------- --------------- --------------- --------------- --------------- server True 192.168.1.45 192.168.1.210 1000000000 1000000000 server True 192.168.1.45 192.168.1.198 1000000000 1000000000 server True 192.168.1.45 192.168.1.197 1000000000 1000000000 server True 192.168.1.45 192.168.1.26 1000000000 1000000000 </code></pre> <p>All four 1 GbE interfaces on the Synology were participating in the SMB connection.</p> <p>My Windows machine currently has a 2.5 GbE adapter (10 gig coming soon), and during the fast copy I was seeing approximately 250 MB/sec arriving from the Synology. That suddenly made the behavior of the system much less mysterious. The Synology was not limited to the throughput of one gigabit Ethernet connection because SMB Multichannel was allowing Windows to use the four available server-side paths, while the 2.5 GbE link on the PC was becoming the smaller network pipe.</p> <p>Synology’s documentation makes an important distinction here between SMB Multichannel and ordinary link aggregation. Multichannel can increase SMB performance for one client by using multiple network connections, while conventional link aggregation is generally about aggregate throughput across multiple clients and services.</p> <p>Like I said, I have a 10 GbE adapter on the way for the Windows machine, so there is another experiment available after the migration. The Synology still only has four 1 GbE interfaces, which gives it 4 Gb/sec of network links in aggregate, but removing the current 2.5 GbE client bottleneck should show how much farther the disks and the Synology itself can go. For an older NAS that I had already mentally demoted to “the slow backup NAS,” it performed surprisingly well.</p> <h4>I also tried rsync</h4> <p>Yes, I know, what about rsync? You are saying Windows as a middleman is unnecessary. The Synology can provide rsync, and UniFi Drive can pull from an rsync server using daemon mode. Ubiquiti documents the rsync path under Drive’s Backup Tasks and requires daemon mode for this type of source.</p> <p>I tried a separate movie share with rsync while the other experiments were going on. It worked, and I saw about 67 MB/sec. It also gave me a destination layout with some additional directory nesting that I would need to clean up afterward.</p> <p>That is not an argument that rsync is slow in general, nor that its directory behavior cannot be configured correctly. It is just what happened in this particular Synology-to-UNAS test. Once the Robocopy path was reaching roughly 187 MB/sec and preserving exactly the UNC share layout I wanted, there wasn’t much incentive for me to make rsync the primary migration mechanism.</p> <p>The slightly amusing result was that the apparently indirect path:</p> <pre><code>Synology -> SMB -> Windows -> SMB -> UNAS </code></pre> <p>was considerably faster in my environment than asking the two NAS devices to transfer the test share directly with the rsync implementation exposed by UniFi Drive. My guess is because rsync wasn't using the 4 1gig connections linked. Let me know what you think in the comments.</p> <h4>The Robocopy command I ended up with</h4> <p>For the normal shares containing lots of files, this is the version I would start with now:</p> <pre><code>robocopy "\\server\share" "\\UNAS-Pro-8\share" /E /MT:4 /R:2 /W:2 /COPY:DATX /DCOPY:DATX /XJ /NP /NFL /NDL /LOG:"%USERPROFILE%\Desktop\nas-migration.log" </code></pre> <p>The switches have fairly specific jobs:</p> <pre><code>/E Copy subdirectories, including empty ones /MT:4 Allow four file-copy threads /R:2 Retry a failed copy twice /W:2 Wait two seconds between retries /COPY:DATX Copy data, attributes and timestamps, but skip ADS /DCOPY:DATX Apply the corresponding directory copy flags /XJ Exclude junction points /NP Don't print percentage progress /NFL Don't log every filename /NDL Don't log every directory /LOG Write the useful output to a file </code></pre> <p>I deliberately do not have <code>/Z</code> in there. I also would not automatically add <code>/J</code>; for a workload dominated by very large files I would test the same transfer both with and without it before committing to a multi-terabyte run.</p> <p>The <code>/MT</code> value is similarly empirical. Four worked extremely well for this Synology and this mix of files, but I would try 1, 4, 8, or another sensible number against a representative slice of the real data rather than assuming that the largest available thread count is best.</p> <h4>Checking the result</h4> <p>For the files where I care enough to prove that the destination contains exactly the same bytes as the source, PowerShell’s <code>Get-FileHash</code> is a convenient final check:</p> <pre><code>Get-FileHash "\\server\share\huge-file.ext" -Algorithm SHA256 Get-FileHash "\\UNAS-Pro-8\share\huge-file.ext" -Algorithm SHA256 </code></pre> <p><code>Get-FileHash</code> uses SHA-256 by default, and if the SHA-256 values match then the two inputs produced the same digest. For enormous files this requires reading the entire file again at both ends, so I am unlikely to hash every song in a music collection, but it is an easy way to verify the particularly valuable multi-hundred-gigabyte files after a migration.</p> <h4>A few things I’d check before blaming the NAS</h4> <p>What made this migration interesting was that the symptoms could have supported several plausible explanations. The UNAS has a new RAID array, the Synology is old, Windows is acting as an SMB client in both directions, the files came from years of different applications, and Robocopy has enough switches to make almost any command line look authoritative.</p> <p>When a file failed, I copied it Synology-to-local and then local-to-UNAS, which exposed the destination-side ADS problem. When large files were slow, I copied the same file Synology-to-local, which proved the old NAS could still deliver about 250 MB/sec. When the network suddenly became much faster, <code>Get-SmbMultichannelConnection</code> showed that all four Synology Ethernet interfaces were participating. When <code>/J</code> looked slow, removing just that behavior restored the throughput I was expecting.</p> <p>The final performance was not the result of finding a secret “fast Robocopy” command from a forum. It came from thinking about which features I actually wanted for this migration and removing a few that were useful in other circumstances but expensive in mine.</p> <p>That is probably the part I will want to remember the next time I do this. <code>/Z</code>, <code>/J</code>, and <code>/MT</code> are not levels on a performance slider. They change restartability, buffering, and concurrency. Alternate Data Streams are real data even when Explorer normally hides them. SMB Multichannel can make an old NAS with several gigabit interfaces much more capable than one might assume from looking at any single Ethernet port.</p> <p>Robocopy ended up being the fastest thing I tried. As with all advice, this worked for me. Ideally you'll gind more value in the comments as Hacker News folks and Windows experts will drop in with better tools and strategies. Just remember, there's more than one way to saturate a network and I completely saturated this one, so I'm pretty happy with the result of my migration.</p><br/><hr/>© 2025 Scott Hanselman. All rights reserved. <br/></div>
Improving Performance in .NET Applications
We all want to write fast code. But writing code that performs well doesn’t come for free. Developers must be cognizant of what their code will do when it is executed, and what tools to use when you want to find the hot spots. In this session, we’ll cover what a .NET developer needs to know to improve the performance of their applications. You’ll see different tools in action and how they can help resolve different performance issues. You will learn: Understand how to address performance issues in code Discover techniques to eliminate bad code before it becomes an issue See how different tools work in .NET to find and fix slow code Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Modern WinForms Development: How AI is Reshaping Your Approach
Artificial intelligence is fundamentally changing how we build and modernize Windows Forms applications. In this session, discover a new development paradigm through two real-world scenarios: Migrating a legacy WinForms LOB application and Building a WinForms-based modern greenfield business solution. You'll see how the WinForms Expert Agent in Visual Studio, the latest Windows .NET 11 runtime features, and custom domain-specific skills work together to accelerate development, reduce boilerplate and tackle common modernization challenges. Whether you're breathing new life into existing applications or starting fresh, learn how AI-informed development transforms your approach to WinForms in 2026. You will learn: New features in both WinForms designer and coming in .NET 11 New approaches to working with WinForms applications in this AI-first world Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Is Claude Code Getting Dumb?
.NET AI Community Standup: Routing & Failover for Microsoft.Extensions.AI
Join Bruno and Joshua to talk about routing and failover for Microsoft.Extensions.AI. Joshua built this during his internship at Microsoft, and he'll walk us through how it works, the design decisions behind it, and how you can use it to make your .NET AI apps more resilient when a model or provider goes down. 🔗 Links: https://learn.microsoft.com/en-us/collections/2gqmsgtg431pgk?source=docs 🎙️ Featuring: Bruno Capuano (https://www.linkedin.com/in/elbruno), Joshua Yue (https://www.linkedin.com/in/joshuajyue/) #dotnet #AI #Resilience
Explore the Future of ASP.NET Core & Blazor in .NET 11
What’s next for web development on .NET? In this session, we’ll explore the future direction of ASP.NET Core and Blazor in .NET 11, highlighting the themes, priorities, and opportunities shaping the platform’s next chapter. Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
.NET MAUI in 2026 - How AI has Transformed App Development Forever
AI is transforming not only how we write code but also how we test code, implement design, and even release our applications. .NET MAUI is part of this AI transformation with new powerful tools from the .NET MAUI engineering team to help streamline your work and help you create as faster than ever. In this session we'll not only just see how to customize GitHub Copilot with the latest for mobile and desktop development, but we will also take a look some productivity boosting enhancements of the team has been making to streamline development. Regardless if you're starting your journey with .NET MAUI today or you've been here since the beginning, everything that you knew about development with .NET MAUI is about to change. Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
.NET Developer Productivity with AI
Modern AI is amazing, but developers need to bring context to AI tooling to gain confidence and dependability. Thankfully, several techniques help developers get what they want out of Agentic workflows - MCP tools, Skills, custom Agents are all easy to wire up with .NET tooling. With basics out of the way, let’s take a look at how Uno Platform helps developers make truly cross-platform .NET apps that run seamlessly on web, desktop & mobile, with AI and Design tools for company. Uno Platform: https://platform.uno/ Uno MCP Tools: https://platform.uno/docs/articles/features/using-the-uno-mcps.html Uno Platform Agent: https://platform.uno/docs/articles/external/studio-docs/Agent/uno-platform-studio-agent.html Uno Platform Skills: https://platform.uno/docs/articles/external/studio-docs/Agent/uno-platform-studio-skills.html ✅ Resources: Uno Platform: https://platform.uno/ Uno MCP Tools: https://platform.uno/docs/articles/features/using-the-uno-mcps.html Uno Platform Agent: https://platform.uno/docs/articles/external/studio-docs/Agent/uno-platform-studio-agent.html Uno Platform Skills: https://platform.uno/docs/articles/external/studio-docs/Agent/uno-platform-studio-skills.html Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Fast Focus: Using Copilot to Build Migration Tools
Migrating can be tough. Moving between versions of a package, or a different package altogether, can be a frustrating experience. With Copilot, you can leverage its' capabilities to create tools as a foundation to provide a deterministic, reliable experience. In this Fast Focus, I'll describe the journey I took to build a tool that was used to make the migration experience painless. You will learn: Understand how to use Copilot to create tools See how different libraries can be used to drive migration Effective techniques to combine Copilot and .NET Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Modernizing .NET Applications
Modernizing legacy .NET applications has never been faster—or more achievable. In this session, you’ll see how Visual Studio 2026, .NET, and GitHub Copilot work together to streamline the upgrade journey, from initial assessment to a clean, modern codebase. We’ll explore how Copilot powered upgrade plans, natural language guidance, and AI driven code fixes accelerate migrations while keeping developers firmly in control. You’ll see practical approaches for updating projects, resolving compatibility issues, and adopting modern .NET features with confidence. We’ll also dig into the tougher challenges that arise in real world modernization efforts: large multi project solutions, older frameworks and libraries, complex technology stacks, and deeply intertwined dependencies. Along the way we’ll highlight patterns and resources that help you navigate these scenarios effectively. If you’re looking to upgrade .NET applications with less friction and more clarity, this session provides a focused, practical roadmap for modernizing faster using the latest AI accelerated tooling. Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Claude Code: Don't /clear Your Session. Do This Instead.
🤖 Learn how to take the best out of Claude Code with me: https://dometrain.com/course/getting-started-claude-code/?ref=gui-ferreira&promo=youtube&promotion=youtube #claudecode #claude #dotnet #ai #aiengineer
Building Intelligent .NET Applications: From AI Features to Agentic System
AI is becoming a core part of modern application development, and .NET offers a practical, incremental way to get started. In this session, you'll learn how to build intelligent .NET applications by adding useful AI capabilities—well beyond the chatbot—using Microsoft.Extensions.AI and .NET’s unified AI abstractions. We'll start with the essentials: integrating large language models, adding features like summarization, classification, and semantic search, and working with both cloud-hosted and local models in a maintainable, production-ready way. You'll see concrete patterns for introducing AI into existing applications with minimal friction. You'll also learn how to ensure quality and governance as you integrate AI into your enterprise. From there, we'll look at how these same foundations scale into more advanced, agentic solutions. You'll get an introduction to agentic development and see how the Microsoft Agent Framework enables applications to reason, plan, and take action using tools and workflows. Whether you're just beginning with AI in .NET or preparing for more autonomous, agent-driven systems, this session provides a clear roadmap from practical AI features to agentic architectures. Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Everything You Need to Know About the Latest in C#
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 recent and upcoming C# features, such as extension members and closed classes. You will learn: Find out what's coming to the next version of C# How to express closed sets of types with unions How to add new members to existing types with extension members Connect with .NET: Blog: https://aka.ms/dotnet/blog Twitter: https://aka.ms/dotnet/twitter TikTok: https://aka.ms/dotnet/tiktok Mastodon: https://aka.ms/dotnet/mastodon LinkedIn: https://aka.ms/dotnet/linkedin Facebook: https://aka.ms/dotnet/facebook Docs: https://learn.microsoft.com/dotnet Forums: https://aka.ms/dotnet/forums 🙋♀️Q&A: https://aka.ms/dotnet-qa 👨🎓Microsoft Learn: https://aka.ms/learndotnet #dotnet
Upgrading to .NET 10: The Breaking Changes That Don't Show Up at Compile Time
Both .NET 8 and .NET 9 stop getting security patches on November 10, 2026 — same date, despite one being LTS and the other STS. Bumping TargetFramework takes five seconds. Finding out what changed underneath it takes longer: EF Core's query translation, whether one failing BackgroundService blocks every other one from starting, and how SQLite reinterprets a DateTimeOffset it's never seen before. I ran every item on this list myself, on both SDKs side by side, before writing any of it down.