Inside Copilot Studio's Upgrade to .NET 10 on WebAssembly: Key Questions Answered

In a recent development, Microsoft's Copilot Studio has upgraded its underlying .NET WebAssembly (WASM) engine from .NET 8 to .NET 10. This move builds on earlier gains described in a previous article about performance improvements from .NET 6 to .NET 8. The upgrade was remarkably smooth, involving mainly a change in the target framework, and it brought two significant enhancements: automatic fingerprinting for asset management and a default-enabled feature that strips unnecessary intermediate language from ahead-of-time compiled code. The following Q&A explores the details of this migration and what it means for Copilot Studio's performance and deployment.

1. What prompted Copilot Studio to upgrade its WebAssembly runtime to .NET 10?

Copilot Studio, which runs C# in the browser via .NET WebAssembly, had already seen notable performance improvements after migrating from .NET 6 to .NET 8. When .NET 10 introduced new features tailored for WebAssembly applications, the team saw an opportunity to further optimize both startup speed and execution efficiency. The upgrade was driven by two key enhancements: automatic fingerprinting of WASM assets (which simplifies caching and integrity validation) and the default enabling of WasmStripILAfterAOT (which reduces the size of ahead-of-time compiled output). These changes promised to streamline deployment and improve runtime performance without requiring major code rewrites. As a result, Copilot Studio transitioned to .NET 10 to take advantage of these built-in capabilities, ultimately delivering a faster, more reliable experience for users.

Inside Copilot Studio's Upgrade to .NET 10 on WebAssembly: Key Questions Answered — Source: devblogs.microsoft.com

2. How straightforward was the migration from .NET 8 to .NET 10 for Copilot Studio?

The migration proved to be remarkably simple. For existing .NET 8 WebAssembly applications, upgrading to .NET 10 typically involves updating the target framework in the .csproj files and verifying that all dependencies are compatible with the new version. For Copilot Studio, this exact approach worked without complications. The team reported that the .NET 10 build is now running in production, and the process required no architectural overhauls or extensive debugging. This smooth transition is a testament to the backward compatibility and maturity of the .NET ecosystem, especially for WebAssembly scenarios. The Copilot Studio team was able to focus on leveraging the new features rather than troubleshooting migration issues, allowing them to quickly realize the benefits of the upgrade.

3. What is automatic fingerprinting and how does it simplify deployment for WebAssembly apps?

Automatic fingerprinting is a new feature in .NET 10 for WebAssembly applications. When you publish a WASM app, each asset's filename is automatically appended with a unique identifier—essentially a fingerprint. This serves two purposes: it provides cache-busting (so browsers always fetch the latest version) and integrity guarantees (ensuring the asset hasn't been tampered with) without any manual intervention. In prior versions, developers had to implement custom solutions to achieve this. Now, resources are imported directly from dotnet.js, fingerprints are part of the published filenames, and integrity validation happens automatically. For Copilot Studio, this meant eliminating a custom PowerShell script that previously renamed files and removed the need to pass explicit integrity arguments from JavaScript. The entire process becomes more reliable and less error-prone, simplifying deployment pipelines significantly.

4. What did Copilot Studio have to do before .NET 10 to handle asset integrity and caching?

Before .NET 10's automatic fingerprinting, Copilot Studio had to implement a multi-step workaround to ensure proper caching and integrity of WASM assets. The process involved three manual steps: first, reading the published blazor.boot.json manifest to enumerate all assets; second, running a custom PowerShell script that renamed each file by appending a SHA256 hash to its filename; and third, explicitly passing an integrity argument from JavaScript when requesting each resource. This custom solution was necessary to prevent outdated files from being served from the browser cache and to detect any file corruption. With .NET 10, all of that manual work is eliminated. The team was able to delete the renaming script and remove the integrity argument from the client-side resource loader. Their existing caching and validation logic on top of these resources continues to work unchanged, but the underlying complexity is gone.

5. What is WasmStripILAfterAOT and why is it beneficial in .NET 10?

WasmStripILAfterAOT is a setting that, when enabled, removes the Intermediate Language (IL) from the published output after the .NET methods have been ahead-of-time (AOT) compiled to WebAssembly. The IL is no longer needed at runtime because the AOT code runs directly, so stripping it reduces the size of the deployment package. In .NET 8, this option existed but defaulted to false, meaning IL was still included. With .NET 10, WasmStripILAfterAOT is enabled by default for AOT builds. For applications like Copilot Studio that use a hybrid packaging strategy—shipping both a JIT engine (for fast startup) and an AOT engine (for maximum speed)—this change means the AOT assemblies are smaller and no longer match their JIT counterparts. Consequently, fewer files can be deduplicated between the two modes, but the overall package size benefit from stripping IL outweighs the loss of deduplication.

6. How does Copilot Studio's hybrid JIT/AOT packaging strategy work?

Copilot Studio uses an advanced packaging approach to balance startup time and steady-state performance. Instead of choosing just one runtime mode, it ships a single NPM package that contains both a JIT (Just-In-Time) compilation engine and an AOT (Ahead-Of-Time) engine. At start, the JIT engine loads quickly, allowing the application to handle initial user interactions almost immediately. In parallel, the AOT engine compiles the entire codebase to WebAssembly for maximum execution speed. Once the AOT engine is ready, control is handed off from the JIT engine to the AOT engine seamlessly. To keep the package size manageable, files that are bit-for-bit identical between the two modes are deduplicated. This strategy gives users a fast first interaction without sacrificing long-term performance. With .NET 10's default stripping of IL for AOT builds, the AOT assemblies differ more from JIT ones, reducing the amount of deduplication possible, but the overall gains from smaller AOT output still benefit the final package.

Tags: