Boosting Copilot Studio's Speed: The Move to .NET 10 on WebAssembly

Introduction

Microsoft's Copilot Studio has long leveraged .NET and WebAssembly to run C# directly in the browser. A recent announcement highlighted the team's upgrade from .NET 8 to .NET 10, promising even faster performance and simpler deployment. This article explores the key improvements—automatic asset fingerprinting and leaner AOT builds—that are making Copilot Studio more responsive and easier to maintain.

Boosting Copilot Studio's Speed: The Move to .NET 10 on WebAssembly — Source: devblogs.microsoft.com

A Seamless Migration Path

Upgrading to .NET 10 was surprisingly straightforward for the Copilot Studio team. The process primarily involved updating the TargetFramework in the project files and ensuring all dependencies aligned with the new runtime. No major refactoring was required, and the .NET 10 build is already running in production. This smooth transition underscores .NET's commitment to backward compatibility and incremental improvement.

Automatic Fingerprinting Simplifies Deployment

One of the most welcome changes in .NET 10 for WebAssembly apps is automatic fingerprinting of assets. When you publish a WebAssembly app, each asset's filename now includes a unique identifier. This built-in mechanism provides cache-busting and integrity guarantees without any manual scripts or configuration.

How It Worked Before

In .NET 8, Copilot Studio (like many WebAssembly apps) had to manually manage asset fingerprinting:

Read the blazor.boot.json manifest 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.

This approach was error-prone and added unnecessary complexity. With .NET 10, all of that disappears. Resources are imported directly from dotnet.js, fingerprints are part of the published filenames, and integrity validation happens automatically. The 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 continues to work unchanged.

Tip: If you load the .NET WASM runtime inside a WebWorker, set dotnetSidecar = true when initializing to ensure proper initialization in a worker context.

Smaller AOT Output with WasmStripILAfterAOT

The other headline improvement for .NET WASM in .NET 10 is that WasmStripILAfterAOT is now enabled by default for AOT builds. After ahead-of-time compiling .NET methods to WebAssembly, the original Intermediate Language (IL) is no longer needed at runtime. By stripping it out, .NET 10 reduces the size of published output significantly. In .NET 8, this setting existed but defaulted to false, so IL was retained even when it wasn't necessary.

Copilot Studio uses a more advanced packaging strategy to get the best of both startup time and steady-state performance. It ships a single npm package that contains both a JIT engine (for fast startup) and an AOT engine (for maximum execution speed). At runtime, Copilot Studio loads JIT and AOT in parallel; the JIT engine handles initial interactions, then control hands off to AOT once it's ready. Files that are bit-for-bit identical between the two modes are deduplicated to keep the package small.

Because WasmStripILAfterAOT produces AOT assemblies that no longer match their JIT counterparts, fewer files can be deduplicated—but the overall payload still shrinks thanks to the removal of IL. The net effect is a smaller, faster-loading package that performs better in users' browsers.

What This Means for Users

For Copilot Studio users, this upgrade translates to faster startup times, more reliable caching, and a smoother overall experience. The automatic fingerprinting eliminates deployment headaches, while the smaller AOT output reduces download sizes without sacrificing performance. Developers working with WebAssembly in .NET can also benefit from these improvements, as they are now baked into the platform.

Conclusion

The move to .NET 10 has brought tangible benefits to Copilot Studio: a simpler deployment pipeline, leaner builds, and the same reliable performance. As .NET continues to evolve, the WebAssembly support becomes increasingly polished, making it easier for teams to build high-performance browser-based applications.

Tags: