When Microsoft introduced WebView2, they solved a major pain point for Windows developers: hosting web content inside a native application without the heavy baggage and security risks of the old WebBrowser control (which relied on Internet Explorer).
However, one term often confuses newcomers: Evergreen.
If you are building a Windows app with WebView2, understanding the "Evergreen" model is critical to deciding how your app will be distributed, updated, and maintained.
Shipping the Fixed Version runtime adds ~150-180 MB to your installer. The Evergreen model keeps your app lightweight—sometimes as small as 100 KB for the bootstrapper.
To get the latest Evergreen Standalone Installer, navigate to the official Microsoft documentation page titled "Download the WebView2 Runtime". Scroll to the "Evergreen Standalone Installer" section and select the architecture (X64, X86, ARM64) appropriate for your deployment environment.
(Note: As per policy, I cannot provide direct download links to executable binaries, but the official Microsoft site is the definitive source.)
The Evergreen WebView2 Runtime is the recommended distribution mode for Windows applications, ensuring your app always uses the latest, most secure version of the Chromium platform. Unlike the "Fixed Version," the Evergreen runtime is not packaged with your app; instead, it is installed once on a client machine and updated automatically by Microsoft. 1. Choose Your Distribution Method
Depending on your app's deployment environment, you can use one of three main methods to ensure the runtime is present:
Evergreen Bootstrapper (Recommended for Online): A small (~2 MB) installer that downloads and installs the architecture-specific runtime from the web.
Evergreen Standalone Installer (For Offline): A full-size installer containing all files needed for machines without an internet connection. Use the official WebView2 Runtime download page to find both versions.
Windows 11 Built-in: The runtime is already included as part of Windows 11 and later. 2. Development Setup
To begin developing with Evergreen WebView2, follow these standard steps:
Install the SDK: Use the NuGet Package Manager in Visual Studio to add Microsoft.Web.WebView2 to your project.
Initialize the Environment: Use CreateCoreWebView2Environment (C++) or EnsureCoreWebView2Async (.NET) without specifying a browser executable folder. This tells the app to look for the system-installed Evergreen runtime.
Handle User Data: Grant your app write permissions to a User Data Folder (UDF) where WebView2 can store cookies and cache. 3. App Deployment Workflow
When deploying your application, your installer should follow this logic:
Detect: Check the Windows Registry to see if the WebView2 Runtime is already installed.
Install: If missing, run the Bootstrapper or Standalone installer.
Silent Install: For a seamless user experience, run the installer with the /silent /install flags from an elevated command prompt to trigger a per-machine installation. 4. Best Practices for Compatibility
Because Evergreen WebView2 updates automatically, you must ensure your app remains compatible with newer versions of Chromium:
Prerelease Testing: Test your app against the Microsoft Edge Preview Channels (Beta, Dev, or Canary) to catch potential regressions before they hit the Stable Evergreen channel.
Avoid Experimental APIs: The Stable Evergreen runtime does not include experimental APIs. Only use these for testing in preview environments.
Performance: Use the Performance Best Practices Guide from Microsoft to optimize startup times and memory usage, such as sharing environments across multiple WebView2 instances. Evergreen webView2 runtime compatability issue? #2210 evergreen webview2
The Evergreen WebView2 Runtime is Microsoft's recommended distribution mode for embedding web technologies into native applications. Unlike the "Fixed Version," the Evergreen runtime is shared across all applications on a device and updates automatically via Microsoft Edge, ensuring applications always have the latest security patches and features. Core Functionality & Architecture
Rendering Engine: Uses Microsoft Edge (Chromium-based) to render HTML, CSS, and JavaScript within native apps.
Process Sharing: WebView2 instances share browser, network, and GPU processes, which optimizes system resources.
Automatic Updates: The runtime is managed by the Microsoft Edge update service, requiring no manual intervention from developers once installed. Distribution & Deployment
Developers typically ensure the runtime is present on client machines through several methods:
Evergreen Bootstrapper: A small (~2MB) executable that downloads the correct runtime architecture (x86, x64, or ARM64) on-demand.
Evergreen Standalone Installer: A full installer containing all binaries, suitable for offline deployment or strictly controlled environments.
Chain Installation: Runtimes can be "chained" into application installers using tools like WiX Burn Bundle or Visual Studio Installer Projects. Key Advantages
Security: Regular, automated updates minimize exposure to known vulnerabilities.
Efficiency: Reduces disk footprint by sharing one copy of the runtime across multiple apps on a single system.
Compatibility: Apps can use the latest WebView2 APIs from the current WebView2 SDK without repackaging the app. Maintenance & Troubleshooting
While automated, certain issues may arise requiring manual intervention:
Repairing: If an app fails to initialize (e.g., throwing a COMException), users can repair the runtime via the "Add or remove programs" menu in Windows.
Forward-Compatibility Testing: Microsoft recommends developers test their apps against Edge preview channels (Canary, Dev, or Beta) to ensure future runtime updates don't break existing functionality.
Detection: Apps should programmatically check for the runtime's existence using the GetAvailableBrowserVersionString method before attempting to initialize a WebView instance. Comparison at a Glance Evergreen Runtime (Recommended) Fixed Version Runtime Update Management Automatic via Microsoft Manual by Developer Disk Footprint Shared (Smaller) Per-app (Larger) Security Always current Developer responsibility Best For Most general applications Apps with strict compatibility needs
Evergreen webView2 runtime compatability issue? #2210 - GitHub
Evergreen WebView2: A Comprehensive Approach to Building Modern Web Applications
Abstract
The rapid evolution of web technologies has led to the development of innovative solutions for building modern web applications. One such solution is WebView2, a component that enables developers to embed web content within their applications. However, managing WebView2 instances can be challenging, especially when it comes to ensuring that the component remains up-to-date and secure. In this paper, we propose the concept of "Evergreen WebView2," a comprehensive approach to building modern web applications that leverages the power of WebView2 while ensuring its perpetual updating and security.
Introduction
WebView2 is a component that allows developers to embed web content within their applications, providing a seamless user experience. It is built on top of the Microsoft Edge browser and provides a range of benefits, including improved performance, enhanced security, and better compatibility with modern web standards. However, managing WebView2 instances can be challenging, especially when it comes to ensuring that the component remains up-to-date and secure.
The Challenges of WebView2 Management
Managing WebView2 instances involves several challenges, including:
The Concept of Evergreen WebView2
To address the challenges of WebView2 management, we propose the concept of "Evergreen WebView2." Evergreen WebView2 is a comprehensive approach to building modern web applications that leverages the power of WebView2 while ensuring its perpetual updating and security.
The key principles of Evergreen WebView2 are:
Benefits of Evergreen WebView2
The benefits of Evergreen WebView2 include:
Implementation of Evergreen WebView2
The implementation of Evergreen WebView2 involves several steps, including:
Conclusion
In this paper, we proposed the concept of "Evergreen WebView2," a comprehensive approach to building modern web applications that leverages the power of WebView2 while ensuring its perpetual updating and security. The benefits of Evergreen WebView2 include improved security, enhanced compatibility, and increased productivity. We believe that Evergreen WebView2 has the potential to revolutionize the way we build modern web applications and look forward to exploring its applications in future research.
Future Work
Future work on Evergreen WebView2 includes:
References
The Evergreen WebView2 Runtime is the recommended distribution model for embedding modern web content into Windows applications. Unlike traditional "Fixed Version" models that bundle a specific static engine, the Evergreen model uses a self-updating system maintained by Microsoft, ensuring your app always runs on the latest Chromium-based rendering engine. Core Architecture and Distribution
The Evergreen Runtime acts as a shared system component. In the Evergreen distribution mode, the runtime is not packaged directly with your application. Instead:
System Integration: It is pre-installed on Windows 11 and pushed to eligible Windows 10 devices through Microsoft 365 Apps.
Shared Footprint: Because multiple apps share a single Evergreen installation, it significantly reduces the disk footprint on the user's machine compared to bundling separate engines for each app.
Automated Maintenance: Microsoft manages the updates, delivering the latest security patches, bug fixes, and web standard updates (typically aligning with Microsoft Edge Stable channel releases). Performance and Security Advantages
Choosing Evergreen is often considered a "future-proofing" move for developers.
Security: Applications automatically receive the latest security improvements without requiring the developer to release a new version of the app.
Optimization: Newer versions of the runtime frequently address legacy issues like memory leaks and high CPU usage.
Feature Access: Developers can use the latest WebView2 APIs from the most recent SDK, knowing the underlying runtime will support them. Implementation Best Practices Understanding the Evergreen WebView2 Runtime: The Future of
While the Evergreen model simplifies maintenance, it introduces specific responsibilities for developers: Distribute your app and the WebView2 Runtime
Mastering Evergreen WebView2: The Future of Embedded Web Content
For years, developers faced a major headache: how to embed web content into desktop apps without forcing users to download massive runtimes or dealing with outdated, insecure browser engines. Enter Microsoft Edge WebView2, and more specifically, its Evergreen distribution mode.
If you’re building for Windows, the Evergreen WebView2 control is likely the most efficient way to bring the power of the modern web into your native applications. Here is everything you need to know about what it is, why it matters, and how it works. What is Evergreen WebView2?
At its core, WebView2 is a developer control that allows you to embed web technologies (HTML, CSS, and JavaScript) into your native apps (using .NET, C++, Java, or WinUI). It uses Microsoft Edge (Chromium) as the rendering engine.
The Evergreen distribution mode means the WebView2 runtime is maintained and updated automatically by Microsoft. Instead of bundling a specific version of the browser engine with your app (the "Fixed Version" approach), your app relies on a shared, system-wide runtime that stays current with the latest security patches and features. The Benefits of Staying Evergreen 1. Zero Maintenance Security
In the "Fixed Version" model, if a major security flaw is found in Chromium, you have to patch your app, recompile it, and push an update to every user. With Evergreen, Microsoft handles the update. As soon as Edge is patched, your app is protected. 2. Smaller Installer Sizes
Because the runtime is shared across the operating system, you don't need to include 100MB+ of browser binaries in your app’s installer. This makes your "lightweight" app actually feel lightweight. 3. Access to Modern Web APIs
Web standards move fast. By using the Evergreen runtime, your application automatically gains support for the latest WebAssembly improvements, CSS Grid features, and JavaScript APIs as they roll out in Chromium. 4. Disk Space Efficiency
If ten different apps on a user’s machine use Evergreen WebView2, they all share the same set of binaries on the disk. This saves significant storage space compared to every app bringing its own "Fixed" version. How it Works: The Runtime and the Loader
When you use Evergreen WebView2, your application uses a small Loader DLL. When the app starts, the Loader looks for the WebView2 Runtime on the user's machine.
Pre-installed: On Windows 10 and 11, the Evergreen WebView2 Runtime is often already installed as part of the OS or alongside Microsoft Edge.
The "Evergreen Bootstrapper": If the runtime isn't found, you can trigger a "Bootstrapper" during your app's installation. This is a tiny file that downloads and installs the correct runtime for the user’s architecture (x64, ARM, etc.) automatically. Evergreen vs. Fixed Version: Which is right for you?
While Evergreen is the recommendation for 99% of use cases, there are times to consider the alternative: Evergreen WebView2 Fixed Version Updates Automatic (Microsoft) Manual (Developer) Disk Space Low (Shared) High (Bundled) Stability Small risk of breaking changes Absolute version control Offline Use Requires initial sync Works fully offline
Choose Evergreen if: You want the best security, smallest file size, and the latest web features.Choose Fixed Version if: You are in a highly regulated environment (like a hospital or flight control system) where every single byte of code must be "frozen" and validated for months. Best Practices for Developers
Check for the Runtime: Always include a check in your app startup code to see if the WebView2 runtime is present. If it’s missing, direct the user to the download page or trigger the bootstrapper.
Handle Version Updates Gracefully: Since the runtime can update while your app is running, listen for the NewBrowserVersionAvailable event to prompt a restart if a critical update occurs.
Use Feature Detection: Instead of checking version numbers, use JavaScript feature detection to ensure the environment supports the APIs you need. Conclusion
The "Evergreen" model represents a shift toward a more secure, collaborative ecosystem. By leveraging Evergreen WebView2, you stop being a "browser maintainer" and go back to being an "app developer." You get the power of Chromium with the ease of a system-managed service.
In software development, "evergreen" means the software automatically updates itself in the background without user intervention. You don't download version 2.0; you just wake up one day and you are on version 2.0.
Chrome, Firefox, and Edge are evergreen browsers. The old Internet Explorer was not (it required OS-level patches).
When Microsoft releases a new WebView2 SDK (e.g., new APIs or performance fixes), you should update your NuGet package and recompile. The new SDK might rely on features or performance guarantees from newer runtimes. Your app will still run on older Evergreen runtimes (down to the minimum version you set), but to use new APIs, you need a newer runtime. Versioning : WebView2 instances need to be updated
Evergreen runtime supports Windows 7 ESU (Extended Security Updates) as well. However, on legacy OS, the runtime won’t auto-update if the OS itself is out of support. Plan accordingly.
Your WinForms app needs to log into Azure AD or Google. Instead of spinning up a separate browser or writing custom HTTP listeners, you embed a tiny WebView2, point it to https://login.microsoftonline.com. Evergreen ensures that the latest security headers, cookie policies, and FIDO2 (passkey) support are available. You never have to update your identity code.