Introduction
Microsoft's Copilot Studio has long leveraged the power of .NET and WebAssembly (WASM) to deliver high-performance conversational AI experiences directly in the browser. Earlier this year, the team detailed how they migrated from .NET 6 to .NET 8, achieving significant speed gains. Now, they've taken another leap forward by upgrading to .NET 10. This article explores the smooth transition, key enhancements, and the tangible benefits that .NET 10 brings to Copilot Studio's WASM engine.
A Seamless Migration to .NET 10
Upgrading an existing .NET 8 WASM application to .NET 10 is remarkably straightforward. For Copilot Studio, the process primarily involved updating the target framework in their project files (e.g., changing <TargetFramework>net8.0</TargetFramework> to net10.0) and ensuring all dependencies were compatible with the new runtime version. The entire migration went smoothly, and the .NET 10 build is now running in production without any major hiccups. This ease of upgrade highlights Microsoft's commitment to backward compatibility and developer convenience.
Automatic Asset Fingerprinting Simplifies Deployment
One of the most impactful improvements in .NET 10 for WebAssembly applications is automatic fingerprinting of WASM assets. When you publish a WASM app, each asset's filename now includes a unique identifier—such as dotnet.wasm.abc123.js. This provides built-in cache busting and integrity guarantees without any manual configuration.
Before .NET 10: A Manual Workflow
Previously, Copilot Studio (like many WASM apps) had to implement custom logic to achieve the same result:
- Read the
blazor.boot.jsonmanifest to enumerate all assets. - Run a custom PowerShell script to rename each file with an appended SHA256 hash.
- Pass an explicit integrity argument from JavaScript when requesting each resource.
What Changed in .NET 10
With automatic fingerprinting, all those manual steps are eliminated. Resources are now imported directly from dotnet.js, fingerprints are part of the published filenames, and integrity validation occurs automatically. The Copilot Studio team was able to delete their custom renaming script and remove the integrity argument from the client-side resource loader. Existing caching and validation logic on top of these resources continued to work unchanged, making the transition frictionless.
Pro Tip: If you load the .NET WASM runtime inside a Web Worker, set dotnetSidecar = true during initialization to ensure proper context setup.
Smaller AOT Output with WasmStripILAfterAOT
The second major improvement in .NET 10 is that WasmStripILAfterAOT is now enabled by default for AOT (Ahead-of-Time) builds. After compiling .NET methods to WebAssembly, the original Intermediate Language (IL) for those methods is no longer needed at runtime. .NET 10 strips this IL from the published output by default, reducing the overall bundle size.
In .NET 8, this setting existed but defaulted to false, meaning IL was retained even when not needed. The change in .NET 10 leads to smaller download sizes and faster load times, especially for applications that rely heavily on AOT compilation.
Copilot Studio's Dual-Engine Strategy
Copilot Studio uses a unique packaging approach to balance startup time and steady-state performance. Instead of relying solely on one engine, they ship a single NPM package containing both a JIT engine (for fast startup) and an AOT engine (for maximum execution speed). At runtime:
- The JIT engine loads quickly and handles initial interactions.
- The AOT engine is loaded in parallel.
- Once the AOT engine is ready, control hands off to it for optimal performance.
Files that are bit-for-bit identical between the two modes are deduplicated to keep the package size efficient.
With WasmStripILAfterAOT enabled, AOT assemblies no longer match their JIT counterparts because the IL is stripped. This means fewer files can be shared between the two engines, but the overall impact is positive: the AOT bundle becomes smaller and loads faster. The Copilot Studio team compensates by optimizing their deduplication logic, ensuring the net result is still a net win in both size and performance.
Conclusion
The upgrade to .NET 10 has delivered tangible benefits for Copilot Studio. The team experienced a smooth migration, eliminated custom scripting with automatic fingerprinting, and achieved smaller AOT outputs thanks to default IL stripping. These improvements enhance the already impressive performance of Copilot Studio's WebAssembly engine, enabling faster load times and more efficient resource utilization.
For developers building .NET WASM applications, the .NET 10 release offers compelling reasons to upgrade. The combination of simplified asset management and leaner AOT builds makes it easier than ever to deliver high-performance web experiences. As Copilot Studio continues to evolve, we can expect further innovations that push the boundaries of what's possible with .NET in the browser.