KO | EN

GitLite

Minimalist Open Source Repository Search Engine

gitlite — search

#typescript #ai-agents #developer-tools #cli #codex #claude-code #react #dsh-plugin #mcp #open-source #dsh #deepseek-harness

WebView2Aot

★ 60 Open GitHub ↗

WebView2 .NET AOT-compatible bindings independent from WinForms, WPF, WinUI or even WinRT.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# WebView2Aot

[Microsoft WebView2](https://developer.microsoft.com/en-us/microsoft-edge/webview2?form=MA13LH) .NET 10+ AOT-compatible bindings 100% independent from WinForms or WPF or WINUI3, or even WinRT.

* **HelloWebView2** is a sample hello world in 40 lignes of C# code (see screenshot below).
* **HelloCompositionWebView2** is a sample hello world that demonstrates the same as HelloWebView2 but using [Visual Composition](https://learn.microsoft.com/en-us/windows/apps/desktop/modernize/ui/visual-layer-in-desktop-apps) instead of a HWND.
* **ScriptHostObjectWebView2** is a sample that demonstrates how to add a host object to the WebView2 scripting context,
and communicate back and forth with it, always with AOT publishing.
* **MarkdownViewer** is a sample that demonstrates how to use WebView2Aot (x64, x86, and ARM64) to display markdown content in a WebView2.
It also shows how to use Winforms .NET 10 + WebView2 + AOT that even works on Windows 7.
* **WebView2** is the .NET Core 10+ AOT-compatible bindings dll that can be used to use WebView2.
* **WebView2Aot.InteropBuilder.Cli** is the tool that generates code in the WebView2 dll.

WebView2 has a dependency to  [DirectN AOT](https://github.com/smourier/DirectNAot) for some Windows definitions (BOOL, PWSTR, etc.) but has zero dependency on any external UI framework.
It doesn't cause problems when compiling AOT since they will get linked directly in the targe binaries.
Ultimately, this dependency could be tweaked manually, if someone want to get rid of it, these C# definitions can just be extracted and compiled separately.

Of course, all this requires the WebView2 to be installed!

## Building
This is all standard .NET code, but to generate WebView2.dll's code, you need to run the **WebView2Aot.InteropBuilder.Cli** project, which will generate the code in the WebView2 project.
This tool uses the **Microsoft.Web.WebView2.Win32.winmd** file for that.

If you're wondering where this winmd file comes from, it's generated using this project https://github.com/smourier/webview2-win32md

## Deployment

You can build `WebView2.dll` yourself as explained in the previous section, 
or you can just use the pre-built Nuget package available here [WebView2Aot Nuget](https://www.nuget.org/packages/WebView2Aot/).

Now, `WebView2.dll` does need at least the native `WebView2Loader.dll` (provided by Microsoft) to work. 
So, to make it easy, `WebView2.dll` comes with a `WebView2Utilities.Initialize` method that will initialize the web view loader if it can find it.

To make it work, you can always reference the standard [Microsoft.Web.WebView2 Nuget](https://www.nuget.org/packages/microsoft.web.webview2) package as usual.
However, it comes with all pre-built WPF & Winforms NET dll and xml, while we only need the native *WebView2Loader.dll* file
(which rarely changes since it's just a bootstrapper that forwards most work to the real current installation runtime binaries).

So `WebView2Utilities.Initialize` also supports two other modes: you can extract the file corresponding to your processor architecture (x86, x64, arm4), or even all files from all architectures, as they rarely change, and either:
1) copy them locally in your app's folder, following the `regular runtimes\[arch]\native\WebView2Loader.dll` relative path
2) embed them as a .NET resource (from Visual Studio, set "Build Action" to "Embedded resource"), for example like this (all examples here are like that):

![image](https://github.com/user-attachments/assets/d08fae48-79d2-4a7c-b693-3bb9be6bcbf6)

What's nice with embedding, especially in AOT deployment cases, is you don't need to ship any other extra file, just one .exe.

## HelloWebView2 sample

![image](https://github.com/user-attachments/assets/885a9167-885a-435e-ad5b-2b4e91ae610c)

## HelloCompositionWebView2 sample

This demonstrates the same as HelloWebView2 but in a Visual Composition (aka Direct Composition) context. In this case, mouse handling (buttons down, up, double clicks, wheel, etc) and cursor changes are handled in the C# code and propagated to the WebView2, as well as Drag & Drop events.

## ScriptHostObjectWebView2 sample

A sample that demonstrates how to add a host object to the WebView2 scripting context, always with AOT publishing:

This is the relevant html part:

```
<body>
    <div id="container">Waiting 2000 ms for .NET function to return...</div>
    <div id="clock"></div>
    <script type="module">

const dotnet = chrome.webview.hostObjects.dotnet;
        dotnet.getInfoAsync(2000).then((value) => { document.getElementById('container').innerText = ".NET returned: " + value; });

// just show a clock while working...
        function showClock() { clock.innerText = new Date().toLocaleTimeString(); dotnet.onClockTick(new Date()); }
        showClock();
        setInterval(showClock, 1000);

</script>
</body>
```

And the host object which is named 'dotnet' in the previous javascript code, based on the still alive [IDispatch](https://learn.microsoft.com/en-us/windows/win32/api/oaidl/nn-oaidl-idispatch) COM interface, and [VARIANT](https://learn.microsoft.com/en-us/windows/win32/api/oaidl/ns-oaidl-variant) types.
These are here extensively interop'd thanks to DirectN, so it's quite transparent to .NET Core. .NET Tasks are also supported.

```
[GeneratedComClass]
public partial class HostObject : DispatchObject
{
    public event EventHandler<string>? ClockTick;

// non async method
    public string GetInfo()
    {
        var info = new HostObjectInfo();
        return JsonSerializer.Serialize(info, JsonSourceGenerationContext.Default.HostObjectInfo);
    }

// async method
    public Task<string> GetInfoAsync(int delay) => Task.Run(async () =>
    {
        await Task.Delay(delay).ConfigureAwait(false); // simulate some async work
        return GetInfo();
    });

public void OnClockTick(string date) => ClockTick?.Invoke(this, date);

// note this is necessary to avoid trimming Task<T>.Result for AOT publishing
    // all Task<T> results should be unwrapped here, so you can return any type you want (string being by far the most used one)
    protected override object? GetTaskResult(Task task)
    {
        if (task is Task<string> s)
            return s.Result;

return null;
    }
}
```

## MarkdownViewer application
A sample that demonstrates how to use WebView2Aot (x64, x86, and ARM64) to display markdown content in a WebView2.
It's a Winforms 10 (.NET 10), yes you read that right, Winforms on .NET 10 with AOT publishing, so,
it even works on Windows 7, with, as usual, only one file (7M) to deploy!

Markdown is converted to HTML using [Markdig](https://github.com/xoofx/markdig)

This README.md file rendered by MarkDownViewer:

Markdown Viewer running in Windows 7 (the look is not as good as on Windows 10/11 because the supported WebView2 on Windows 7 doesn't understand some new CSS constructs):

# AOTrino
[AOTrino](https://github.com/aelyo-softworks/AOTrino) is Electron-like desktop apps on .NET Native AOT + WebView2. One executable, no runtime to install, no Chromium to ship — Windows already has both. x86, x64 and ARM64.

A window is a real HWND, the UI is a web page, and the two talk over a typed bridge. That's the whole idea. The Fluent UI gallery below is an AOTrino app, and it weighs 4 MB.

## ShellBat application
With WebView2 native AOT bindings, you can build highly capable applications, on par with Electron or Tauri, without leaving the .NET ecosystem. [ShellBat](https://github.com/smourier/ShellBat), packaged as a single executable, is a modern Windows file explorer featuring file viewers, multi-instance workflows, terminal integration, search functionality, and deep Windows Shell integration, all powered by WebView2 for its user interface.

# ActiveN
[ActiveN](https://github.com/smourier/ActiveN) is a lightweight framework for building classic COM components and OLE/ActiveX controls in modern fully AOT-compatible .NET, with registration-ready deployment.

It lets you author controls and automation objects that run inside legacy or current COM hosts (VBA, VB6, Delphi, Visual Fox Pro, scripting engines, test containers, etc.) without relying on WinForms or WPF (since they are currently not AOT-compatible).

Check out this 1998 VB6 IDE (x86) hosting modern WebView2 :-)

WebView2Aot

Explore Similar Repositories

Was this content helpful?

Recent Feedback

Download README