How Microsoft Copilot Studio Accelerates with .NET 10 and WebAssembly

Seamless Upgrade to .NET 10

Microsoft Copilot Studio, the platform that enables C# code to run directly in the browser via .NET WebAssembly (WASM), has recently completed a major engine upgrade. After previously migrating from .NET 6 to .NET 8 and documenting significant performance gains, the team has now moved to .NET 10. The transition was remarkably straightforward—updating the target framework in project files and verifying dependency compatibility was all it took. Today, the .NET 10 build is already live in production, delivering faster load times and smoother interactions for users.

Automatic Fingerprinting Streamlines Deployment

One of the most impactful changes in .NET 10 for WASM applications is the introduction of automatic fingerprinting for assets. When a WebAssembly app is published, each resource file now includes a unique identifier in its filename. This built-in feature provides both cache busting and integrity verification without any manual configuration.

Prior to this update, teams like Copilot Studio had to jump through several hoops to achieve the same result. The old workflow involved:

• Reading the blazor.boot.json manifest to list all assets
• Running a custom PowerShell script to append a SHA256 hash to each filename
• Passing an explicit integrity argument from JavaScript when loading each resource

With .NET 10, all those steps are eliminated. The runtime’s dotnet.js imports resources directly, fingerprints are embedded in the published filenames, and integrity validation happens automatically. The Copilot Studio team was able to delete their custom renaming script and remove the integrity argument from the client-side loader. Existing caching and validation layers continue to function without changes.

Tip: If you’re loading the .NET WASM runtime inside a WebWorker, set dotnetSidecar = true during initialization to ensure proper context setup.

For deeper details on the migration, see the upgrade section above.

Smaller Builds with WasmStripILAfterAOT

Another headline improvement in .NET 10 is that WasmStripILAfterAOT is now enabled by default for AOT builds. When methods are compiled ahead-of-time to WebAssembly, the original Intermediate Language (IL) is no longer needed at runtime. .NET 10 strips that IL automatically from the published output, reducing the download size for users. In .NET 8, this option existed but was off by default.

Copilot Studio employs a sophisticated packaging strategy to balance fast startup with peak execution speed. The platform ships a single NPM package that contains two engines: a JIT engine for rapid initial loads and an AOT engine for maximum steady-state performance. At runtime, both engines load in parallel—the JIT handles the first user interactions, then control transfers to the AOT engine once it’s ready. To keep the package lean, files that are identical between the two modes are deduplicated.

Because WasmStripILAfterAOT produces AOT assemblies that no longer match their JIT counterparts, fewer files can be shared. However, the overall size reduction from stripping IL more than compensates. The team observed that the AOT engine’s download size decreased by roughly 15–20%, while the JIT engine remained unchanged. This means users enjoy even faster startup times and lower bandwidth consumption on the first visit.

A Hybrid Approach for Optimal Performance

The decision to use both JIT and AOT engines is deliberate. JIT compilation starts executing code almost instantly, making it ideal for initial page load and early interactions. AOT compilation, on the other hand, delivers consistently high performance for long-running operations. By loading them concurrently and handing off control seamlessly, Copilot Studio ensures users never experience a delay.

The .NET 10 update also brought general runtime optimizations that benefit both modes. Reduced memory allocation, faster garbage collection, and improved WebAssembly instruction scheduling all contribute to a snappier experience. Combined with automatic fingerprinting and smaller AOT builds, Copilot Studio now offers a noticeably more responsive interface for its millions of users.

For developers looking to adopt similar techniques, the .NET 10 tooling makes it easier than ever. The built-in fingerprinting alone eliminates hours of manual configuration, while the default WasmStripILAfterAOT reduces payload sizes without compromising functionality. As WebAssembly continues to mature, .NET remains at the forefront of bringing full-featured applications to the browser.