Boosting Copilot Studio: How the .NET 10 WebAssembly Upgrade Delivers Speed and Simplicity

Copilot Studio recently completed a major upgrade from .NET 8 to .NET 10 for its WebAssembly engine, bringing notable performance improvements and simplifying deployment. This Q&A explores key aspects of the migration, including smoother upgrades, automatic asset fingerprinting, and leaner AOT builds. Whether you're a developer using Copilot Studio or building your own WASM apps, these insights highlight practical benefits of adopting .NET 10.

What made the upgrade from .NET 8 to .NET 10 so smooth for Copilot Studio?

Moving an existing .NET WebAssembly application to a new runtime can be complex, but for Copilot Studio, the process was remarkably straightforward. The team simply updated the target framework in their .csproj files and verified that all dependencies were compatible with .NET 10. No major code refactoring or custom migration steps were required. Once these changes were made, the .NET 10 build was deployed directly into production without hiccups. This seamless transition underscores Microsoft's focus on backward compatibility and incremental improvement in the .NET ecosystem. Developers can expect similar ease when upgrading their own WASM projects, provided they follow standard package update practices.

How does automatic fingerprinting in .NET 10 simplify WebAssembly deployment?

Automatic fingerprinting eliminates manual asset management headaches. When you publish a WebAssembly app with .NET 10, each asset's filename now includes a unique identifier derived from its content. This provides built-in cache-busting and integrity verification without any extra scripting. Previously, Copilot Studio had to read the blazor.boot.json manifest, run a custom PowerShell script to append SHA256 hashes to each file, and pass explicit integrity arguments from JavaScript when loading resources. With .NET 10, all that custom code is unnecessary. Resources are imported directly from dotnet.js, fingerprints are part of the published filenames, and integrity validation happens automatically. The team could delete their renaming script and remove the integrity argument from the client-side resource loader, while existing caching logic continued to work unchanged. This reduces maintenance overhead and bug potential.

What is WasmStripILAfterAOT and how does it benefit app size?

WasmStripILAfterAOT is a feature that removes the original Intermediate Language (IL) from assemblies after ahead-of-time compilation to WebAssembly. Since AOT-compiled methods no longer need the IL at runtime, stripping it reduces the published output size. In .NET 8, this setting existed but defaulted to false. As of .NET 10, it is enabled by default for AOT builds, giving all WASM apps an automatic size reduction. For Copilot Studio, this change contributed to a leaner package, especially important because they ship both a JIT engine (for fast startup) and an AOT engine (for peak execution speed) in a single NPM package. The stripping ensures that duplicate IL is eliminated, while files identical between the two modes are deduplicated, keeping the overall download size manageable.

Why does Copilot Studio ship both a JIT and an AOT engine, and how do they work together?

Copilot Studio uses a dual-engine strategy to balance startup speed and steady-state performance. The JIT (Just-In-Time) engine loads quickly, allowing users to interact with the application almost immediately. Meanwhile, the AOT (Ahead-of-Time) engine compiles .NET methods to native WebAssembly in the background. Once the AOT engine is ready, control smoothly transitions from the JIT to the AOT runtime, which executes faster for ongoing interactions. Both engines are packaged in a single NPM package, and files that are bit-for-bit identical (like core libraries) are shared to minimize redundancy. This approach gives users the best of both worlds: immediate responsiveness and long-term efficiency. The .NET 10 upgrade further enhanced this by enabling WasmStripILAfterAOT by default, which reduces the AOT output size and makes the dual-engine package even smaller.

Is there a special tip for loading .NET WASM inside a Web Worker?

Yes, if you load the .NET WebAssembly runtime inside a Web Worker, you need to set dotnetSidecar = true when initializing. This ensures proper initialization in a worker context, which differs from the main thread. Copilot Studio uses this technique to offload processing and keep the UI responsive. Without this flag, the runtime may fail to set up correctly because workers have different global objects and threading requirements. This tip applies to any .NET WASM app targeting a worker, so check your initialization code if you're adopting .NET 10 in a multithreaded or parallel scenario.

What are the overall performance and deployment gains from moving to .NET 10?

The upgrade delivered two main wins: simplified deployment via automatic fingerprinting, and smaller AOT output thanks to default IL stripping. Together, they reduce manual scripting, lower the risk of misconfiguration, and shrink download sizes. The Copilot Studio team was able to delete custom PowerShell scripts and remove integrity arguments from their resource loader. The dual JIT/AOT approach continued to work without changes, benefiting from the leaner AOT builds. For developers using Copilot Studio, this means faster page loads and smoother interactions, while developers building similar apps can adopt these patterns to achieve similar improvements. The upgrade path was frictionless, showing that .NET 10 is a mature, production-ready platform for WebAssembly applications.