A Seamless Migration to .NET 10
The Copilot Studio team has successfully upgraded their WebAssembly (WASM) runtime from .NET 8 to .NET 10, building on earlier moves from .NET 6. This latest transition brought notable performance and developer experience improvements, all while maintaining a smooth deployment process. The upgrade required updating target framework references in project files and ensuring dependency compatibility—a straightforward process that delivered immediate gains.
Updating Framework and Dependencies
Migrating an existing .NET 8 WASM application to .NET 10 is largely a matter of adjusting the .csproj files and verifying that all third-party libraries support the new version. For Copilot Studio, this step was executed without major issues, and the .NET 10 build is now running in production. This seamless upgrade path underscores the maturity of the .NET ecosystem for WebAssembly applications.
Enhanced Deployment with Automatic Fingerprinting
One of the most impactful changes in .NET 10 for WebAssembly is the automatic fingerprinting of WASM assets. When publishing a WebAssembly app, each asset's filename now includes a unique identifier derived from its content. This provides built-in cache-busting and integrity verification without any manual configuration.
Eliminating Manual Scripts
Previously, Copilot Studio had to manage fingerprinting manually through a multi-step process:
- Read the
blazor.boot.jsonmanifest to enumerate all assets. - Run a custom PowerShell script to rename each file with an appended SHA256 hash.
- Pass explicit integrity arguments from JavaScript when requesting each resource.
With .NET 10, all of that complexity is eliminated. Resources are imported directly from dotnet.js, fingerprints are embedded in filenames, and integrity checks occur automatically. The team was able to delete the custom renaming script and remove the integrity argument from the client-side resource loader, simplifying deployment pipelines and reducing maintenance overhead.
Security and Caching Benefits
Beyond convenience, automatic fingerprinting enhances security by verifying resource integrity on the fly. It also improves caching behavior: because each file's name changes when its content changes, browsers and CDNs always fetch the correct version. Existing caching and validation logic on top of these resources continues to work unchanged, ensuring backward compatibility.
Tip: If you load the .NET WASM runtime inside a WebWorker, set dotnetSidecar = true during initialization to ensure proper context handling.
Smaller Output via WasmStripILAfterAOT
Another key improvement in .NET 10 is that WasmStripILAfterAOT is now enabled by default for Ahead-of-Time (AOT) builds. After converting .NET methods to WebAssembly, the original Intermediate Language (IL) code is no longer needed at runtime. .NET 10 strips this IL from published output, reducing download sizes and improving load times.
Default IL Stripping in .NET 10
In .NET 8, WasmStripILAfterAOT existed but defaulted to false. Copilot Studio previously had to enable it manually. Now, the default setting delivers smaller output for all AOT applications, further optimizing performance without developer effort.
Dual Engine Strategy: JIT and AOT
Copilot Studio employs a sophisticated packaging approach to balance startup speed and long-term performance. It ships a single NPM package containing both a Just-in-Time (JIT) engine for fast startup and an AOT engine for maximum execution speed. At runtime, the JIT engine loads first, handling initial interactions while the AOT engine compiles in parallel. Once ready, control seamlessly hands off to AOT.
To keep the package size minimal, files that are bit-for-bit identical between the two modes are deduplicated. However, because WasmStripILAfterAOT alters AOT assemblies so they no longer match their JIT counterparts, fewer files can now be deduplicated. This trade-off is offset by the overall reduction in AOT output size, especially for larger applications.
In summary, Copilot Studio's upgrade to .NET 10 demonstrates how incremental improvements in the .NET WebAssembly ecosystem—like automatic fingerprinting and default IL stripping—can streamline development and boost application performance. The combination of smooth migration, reduced manual scripting, and smaller payloads makes .NET 10 a compelling choice for modern WebAssembly workloads.