Ultimate Web View

1Overview

Ultimate Web View puts web pages into a Unity project. On Windows and Linux it ships its own browser engine (Chromium 156) and draws pages into a texture, so a page can sit on any mesh, in a uGUI RawImage or in a UI Toolkit element. On Android and iOS it uses the web view of the device, as a texture or as a native view over the game. In WebGL builds the page is an iframe placed over the canvas. The same C# API drives all of them. This documentation is both the manual and the scripting reference.

Key features

How it works

Everything is built on one class, WebView. It owns a browser instance, exposes its page as a Texture, and has methods for navigation, pointer and keyboard input and JavaScript. The components and the UI Toolkit element are thin wrappers that create a WebView, show its texture and feed it input.

Two conventions apply everywhere. Points are normalised: (0, 0) is the top-left corner of the page and (1, 1) the bottom-right. Everything runs on the main thread: call the API from the main thread, and expect every event there.

Platforms at a glance

The full comparison is in section 7.

2Requirements

Some features depend on the Unity version:

If your scripts live in their own assembly definition, add a reference to HyTeKGames.UltimateWebView. All types are in the namespace HyTeKGames.UltimateWebView.

3Installation and first steps

Import the package and you're done: there is no setup wizard, no scripting define to add and no package to install. Nothing opens on import. Start from the Welcome window when you want a guided first step.

Importing the package

Import Ultimate Web View from the Package Manager (My Assets). Everything goes to Assets/HyTeKGames/UltimateWebView. You can move that folder: the package finds its own files by name.

The first import takes a while because the engine files are large. The first time a web view starts in the Editor, the package copies the engine to Library/UltimateWebView and shows a progress bar: Preparing the browser engine (once per project).... The Editor runs that copy, so the files in Assets are never locked and you can update or delete the package while the Editor is open.

Menus

The components are also in Add Component > Ultimate Web View.

Your first web view

1. Add a screen Choose GameObject > Ultimate Web View > Web View Screen, or click Add a Web View Screen in the Welcome window. A quad appears in front of the Scene view camera.
2. Set the URL Select the new object. In its Web View Screen component, open Options and type an address into Url, for example https://example.com.
3. Add a pointer Choose GameObject > Ultimate Web View > Web View Pointer. Your main camera gets the component that turns the mouse into clicks on the screen.
4. Press Play The page loads and shows on the quad. Click links, scroll with the wheel, click a text field and type.

The Browser window

Tools > HyTeKGames > Ultimate Web View > Browser opens a small browser that runs in edit mode and in play mode. Use it to check that a site works in the engine before you build a scene around it, or to keep a reference page next to the Scene view.

• The toolbar has Back, Forward, Reload (it becomes Stop while loading) and an address field. Press Enter to load what you typed: an address is loaded as it is, anything else is searched for. Esc puts the current address back.
• The menu button on the right offers Developer Tools, Zoom In, Zoom Out, Reset Zoom, Copy Address, Open in System Browser and Home.
• JavaScript alerts and confirmations show as Editor dialogs. The window doesn't save downloads.

The window is an ordinary EditorWindow with a WebViewElement in it. Its source, Editor/Browser/BrowserWindow.cs, is a good model for your own editor tools.

Demo scenes

The Demo folder holds four scenes. They work in the Built-in pipeline, URP and HDRP without conversion, and with either input backend. The pages they show are HTML text assets in Demo/Pages, so the demos also run without an internet connection.

The Welcome window has a Demo scenes tile that shows the folder in the Project window. You can delete the Demo folder at any time: nothing else depends on it.

4Quick start recipes

Each recipe is self-contained. The C# samples assume using HyTeKGames.UltimateWebView; and using UnityEngine; at the top of the file. What a recipe describes is the behaviour on Windows and Linux; where another platform differs, section 7 says how.

Web page in a uGUI canvas

WebViewImage shows a page in a RawImage. Pointer input comes from the EventSystem, so it works with every input module and ray caster: screen-space canvases, world-space canvases and XR ray interactors.

1. Choose GameObject > Ultimate Web View > Web View Image. If the scene has no canvas or EventSystem, they are created.
2. Set Options > Url on the Web View Image component and size the RectTransform as you like.
3. Press Play.

With Match Rect Size on (the default), the texture has the size of the image on screen, so text is as sharp as the rest of your UI and the page reflows when the rect changes. Clicking the image selects it in the EventSystem and gives the page keyboard focus; selecting something else takes focus away.

Drive it from a script through the component. The web view exists from the moment the component is first enabled in play mode:

using HyTeKGames.UltimateWebView;
using UnityEngine;
using UnityEngine.UI;

public sealed class HelpPanel : MonoBehaviour
{
    public WebViewImage page;
    public Text title;

    void OnEnable()
    {
        page.Created += OnCreated;
        if (page.WebView != null) OnCreated(page.WebView);
    }

    void OnDisable()
    {
        page.Created -= OnCreated;
        if (page.WebView != null) page.WebView.TitleChanged -= OnTitleChanged;
    }

    void OnCreated(WebView webView)
    {
        webView.TitleChanged -= OnTitleChanged;
        webView.TitleChanged += OnTitleChanged;
    }

    void OnTitleChanged(string text)
    {
        title.text = text;
    }

    // Hook this to a Button.
    public void ShowHelp()
    {
        page.Url = "https://example.com/help";
    }
}

The component also has three UnityEvents in the Inspector, On Ready, On Page Loaded and On Message, for wiring without code.

Web page on a 3D object

WebViewScreen shows a page on a mesh: a quad, a plane, the screen of a monitor model. WebViewPointer aims at such screens with a physics ray and turns mouse, touch or your own calls into clicks, drags and scrolling.

1. Choose GameObject > Ultimate Web View > Web View Screen, or add the Web View Screen component to your own mesh. The object needs a collider; adding the component to a mesh without one adds a MeshCollider.
2. Set Options > Url and Resolution. With Match Aspect on, only the width counts: the height follows the proportions of the mesh, so the page is never stretched.
3. Choose GameObject > Ultimate Web View > Web View Pointer to put a pointer on the main camera.

The material. If the renderer still has the default material Unity gives new primitives, or no working material at all, the component replaces it at run time with its own unlit shader (HyTeKGames/Ultimate Web View/Screen), which works in the Built-in pipeline, URP and HDRP. If you assigned your own material, it is kept and the page texture is set on it through a MaterialPropertyBlock: on the property named in Texture Property, or on every one of _MainTex, _BaseMap, _BaseColorMap, _UnlitColorMap and _EmissionMap the material has. Use an unlit or emissive material unless you want scene lighting on the page.

The surface. The page lies on the two largest dimensions of the mesh: X and Y for Unity's quad, X and Z for Unity's plane. For clicks, a MeshCollider on a readable mesh uses the UV coordinates of the hit, so curved screens work. Other colliders use the position of the hit inside the mesh bounds.

The pointer. Pick how it aims with Mode:

Screens must be on a layer included in the pointer's Layers and within Max Distance. With Cursor on Auto, the system mouse cursor takes the shape the page asks for in Mouse mode, and a small cursor is drawn on the surface in the other modes.

Driving the pointer from an XR controller or a gamepad:

public sealed class ControllerPointer : MonoBehaviour
{
    // Mode: Transform, Read Mouse: off.
    public WebViewPointer pointer;

    public void OnTriggerDown()
    {
        pointer.Press();
    }

    public void OnTriggerUp()
    {
        pointer.Release();
    }

    // stick.y is positive when pushed up; page pixels are positive downwards.
    public void OnStick(Vector2 stick)
    {
        pointer.Scroll(new Vector2(stick.x, -stick.y) * 30f);
    }
}

Building a screen from code:

GameObject quad = GameObject.CreatePrimitive(PrimitiveType.Quad);   // comes with a MeshCollider
quad.transform.localScale = new Vector3(1.6f, 0.9f, 1f);
WebViewScreen screen = quad.AddComponent<WebViewScreen>();
screen.Url = "https://example.com";

Camera.main.gameObject.AddComponent<WebViewPointer>();

Web page in UI Toolkit

WebViewElement is a VisualElement. It creates its web view once it is on a panel and has a size, sizes the texture to the element, and feeds it pointer, wheel and keyboard events. It works in runtime UIDocuments (Unity 2021.2 and newer) and in editor windows (every supported version).

In UXML:

<ui:UXML xmlns:ui="UnityEngine.UIElements" xmlns:uwv="HyTeKGames.UltimateWebView">
    <ui:Label text="News" />
    <uwv:WebViewElement name="page" url="https://example.com" style="flex-grow: 1;" />
</ui:UXML>

In C#:

using HyTeKGames.UltimateWebView;
using UnityEngine;
using UnityEngine.UIElements;

[RequireComponent(typeof(UIDocument))]
public sealed class NewsScreen : MonoBehaviour
{
    WebViewElement page;

    void OnEnable()
    {
        VisualElement root = GetComponent<UIDocument>().rootVisualElement;
        page = new WebViewElement();
        page.style.flexGrow = 1f;
        page.Url = "https://example.com";
        page.Created += OnCreated;
        root.Add(page);
    }

    void OnDisable()
    {
        page.Created -= OnCreated;
        page.RemoveFromHierarchy();
    }

    void OnCreated(WebView webView)
    {
        webView.LoadFinished += OnLoaded;
    }

    void OnLoaded(string url)
    {
        Debug.Log("Loaded " + url);
    }
}

Things to know:

• Give the element a size (flex-grow, or a width and height). Without one no web view is created.
• The element takes UI Toolkit focus when clicked, and the keys it receives go to the page. Its web view doesn't use the play-mode hardware keyboard forwarder, so it also types in editor windows.
• Options holds the remaining settings (popups, startup script and so on). Change them before the element is added to a panel. The address, transparency and pixel density come from the element's own properties, not from Options.
• A web view the element created is disposed about a second after the element leaves its panel, and a new one is created when it comes back. Dispose() does it immediately.
• To show a web view you created yourself, assign it: page.WebView = myWebView;. The element then never resizes or disposes it.

An editor window takes a few lines:

using HyTeKGames.UltimateWebView;
using UnityEditor;

public sealed class ReferenceWindow : EditorWindow
{
    [MenuItem("Window/Reference Page")]
    static void Open()
    {
        GetWindow<ReferenceWindow>();
    }

    void OnEnable()
    {
        var page = new WebViewElement();
        page.style.flexGrow = 1f;
        page.Url = "https://example.com";
        rootVisualElement.Add(page);
    }
}

Scripting only: the WebView class

WebView is a plain C# class, not a component. Create one, put its Texture on anything, send it input, and dispose it when you're done.

public sealed class ScriptedPage : MonoBehaviour
{
    public Renderer target;

    WebView webView;

    void Start()
    {
        var options = new WebViewOptions();
        options.url = "https://example.com";
        options.frameRate = 30;

        webView = new WebView(1280, 720, options);
        webView.LoadFinished += OnLoaded;
        webView.LoadFailed += OnFailed;
        target.material.mainTexture = webView.Texture;
    }

    void OnLoaded(string url)
    {
        Debug.Log("Loaded " + webView.Title + " from " + url);
    }

    void OnFailed(LoadError error)
    {
        Debug.LogWarning("Could not load " + error.url + ": " + error.description);
    }

    void OnDestroy()
    {
        if (webView != null) webView.Dispose();
    }
}

The texture is always upright and keeps the same object when the web view is resized, so assign it once. Calls made before the engine has created the browser are queued: you don't have to wait for Ready.

Input uses normalised points, (0, 0) top-left:

Vector2 centre = new Vector2(0.5f, 0.5f);

webView.Click(centre);                              // move, press, release
webView.Scroll(centre, new Vector2(0f, 300f));      // 300 page pixels down
webView.TypeText("unity web view");
webView.SendKey(WebKey.Enter);
webView.SendKey(WebKey.A, KeyModifiers.Control);    // select all

// Or the single steps, for drags and hover:
webView.PointerMove(new Vector2(0.2f, 0.4f));
webView.PointerDown(new Vector2(0.2f, 0.4f));
webView.PointerMove(new Vector2(0.6f, 0.4f));
webView.PointerUp(new Vector2(0.6f, 0.4f));

If you prefer await, two methods return tasks that complete on the main thread:

async void Start()
{
    var webView = new WebView(1024, 768, "https://example.com");
    bool loaded = await webView.WaitForLoadAsync();
    if (loaded)
    {
        string json = await webView.EvaluateJavaScriptAsync("document.title");
        Debug.Log(json);   // "Example Domain", with the quotes: results are JSON
    }
    webView.Dispose();
}

C# and JavaScript

Every page gets a small object, window.uwv, before its own scripts run. It carries messages in both directions. Messages are strings; send JSON when you need structure.

In the page:

// Page to Unity. Objects are sent as JSON, strings as they are.
uwv.postMessage({ type: 'buy', item: 'sword' });

// Unity to page.
uwv.addEventListener('message', function (e) {
    var state = JSON.parse(e.data);
    document.getElementById('gold').textContent = state.gold;
});

uwv.onmessage = function (e) { ... } and uwv.removeEventListener('message', listener) work too. On the desktop engine window.uwv exists before the first script of the page. If your page must also run where the bridge arrives a moment later, wait for it:

if (window.uwv) start();
else window.addEventListener('uwvready', start);

In Unity:

[System.Serializable]
public sealed class ShopCommand
{
    public string type;
    public string item;
}

void Listen(WebView webView)
{
    webView.MessageReceived += OnMessage;
}

void OnMessage(string json)
{
    ShopCommand command = JsonUtility.FromJson<ShopCommand>(json);
    if (command.type == "buy") Debug.Log("The player buys " + command.item);
}

void SendGold(WebView webView, int gold)
{
    webView.PostMessage("{\"gold\":" + gold + "}");
}

With the components, On Message in the Inspector and component.PostMessage(...) do the same without touching WebView.

Running JavaScript. ExecuteJavaScript runs a script and forgets it. EvaluateJavaScript hands you the value of the last expression as JSON: 42, "text", {"a":1} or null.

webView.ExecuteJavaScript("document.body.style.zoom = '1.2'");

webView.EvaluateJavaScript("document.querySelectorAll('a').length", OnCounted, OnScriptError);

void OnCounted(string json)
{
    Debug.Log("The page has " + int.Parse(json) + " links.");
}

void OnScriptError(string message)
{
    Debug.LogWarning("The script failed: " + message);
}

EvaluateJavaScriptAsync is the awaitable form; it throws a WebViewException when the script throws.

Startup script. WebViewOptions.startupScript (or the StartupScript property, from the next page load on) is JavaScript that runs in every page of the web view before the page's own scripts. Use it to define globals or to hook functions:

var options = new WebViewOptions();
options.url = "https://example.com";
options.startupScript = "window.gameVersion = '1.4.2';";
var webView = new WebView(1280, 720, options);

In WebGL builds all of this works for pages of the same origin as the game. Pages of other origins need a different handshake: see WebGL.

HTML strings and local files

LoadHtml shows a page from a string, for example from a TextAsset:

public TextAsset page;

void Show(WebView webView)
{
    webView.LoadHtml(page.text);

    // With a base address: relative links resolve against it, and it decides the storage origin.
    webView.LoadHtml(page.text, "https://game.example/ui/");
}

Without a base address the page gets https://app.localhost/, so it has a real origin: local storage and cookies work, and fetch behaves as on a normal site. Nothing is requested from that address. Chromium treats such a page as a public site, and public sites normally need a permission to call servers on the local network. On Windows and Linux the engine switches those local network access checks off, so the page can reach a server on the same machine (http://localhost:8080). If a page must talk to a local server on Android, iOS or WebGL too, pass the address of that server as the base address: the page then belongs to its origin.

For pages made of several files (scripts, style sheets, images), put them in StreamingAssets and load the entry file by address:

webView.LoadUrl("streaming-assets://ui/index.html");

// The same, as an ordinary address you can also hand to other code:
string address = WebView.StreamingAssetsUrl("ui/index.html");

The streaming-assets:// scheme works on every platform and in Options > Url too. Such a page loads its scripts, style sheets, images and media from neighbouring files as it is. Reading other local files with fetch, XHR or ES modules needs the setting Local file access, which is off by default.

How LoadUrl reads what you give it:

Cookies and stored data

All web views share one browser profile: cookies, local storage, IndexedDB and the HTTP cache. WebViewData is the static class that reads and clears it.

void SignIn(string token)
{
    var cookie = new WebCookie();
    cookie.name = "session";
    cookie.value = token;
    cookie.domain = "example.com";
    cookie.path = "/";
    cookie.secure = true;
    cookie.httpOnly = true;
    cookie.expires = System.DateTimeOffset.UtcNow.AddDays(30).ToUnixTimeSeconds();   // 0 = session cookie
    WebViewData.SetCookie("https://example.com", cookie);
}

void ListCookies()
{
    WebViewData.GetCookies("https://example.com", OnCookies);
}

void OnCookies(WebCookie[] cookies)
{
    foreach (WebCookie c in cookies) Debug.Log(c.name + " = " + c.value);
}

void SignOut()
{
    WebViewData.DeleteCookies("https://example.com", "session");   // leave the name out to delete all of them
}

Where the profile lives on Windows and Linux:

WebViewOptions.incognito keeps the cookies and storage of one web view in memory only, apart from the shared profile. On Android and iOS the cookie calls have limits (see Android), and in WebGL builds WebViewData does nothing because cookies belong to the browser.

Page sound through Unity audio

On Windows and Linux the engine hands the sound of each page to Unity, and it plays through an AudioSource. That makes it part of your mix: volume, mixer groups, effects, pausing with the AudioListener, and 3D position.

• Nothing to do for plain sound. A web view that starts playing gets an automatic 2D AudioSource.
• 3D sound. Put an AudioSource and a Web View Audio component on the same object as the WebViewScreen (or use GameObject > Ultimate Web View > Web View Screen (3D Sound)). Set Spatial Blend to 1 and shape the roll-off as for any source. The screen binds to it when it creates its web view.
• Your own web view. Bind it from code, as below.

void AddSpeaker(GameObject speaker, WebView webView)
{
    AudioSource source = speaker.AddComponent<AudioSource>();
    source.spatialBlend = 1f;
    source.maxDistance = 15f;

    WebViewAudio output = speaker.AddComponent<WebViewAudio>();
    output.Bind(webView);
}

The AudioSource only plays while the page makes sound, so silent pages don't hold a voice. WebView.Muted silences a page, IsPlayingAudio and AudioStateChanged tell you when it makes sound. A web view has one output: binding it to another WebViewAudio releases the previous one.

Turn Options > Unity Audio off to let the engine play through the system output directly, outside Unity's mix. On Android, iOS and WebGL the browser always plays its own sound: WebViewAudio does nothing there, and 3D sound from pages isn't possible.

On-screen keyboard

WebViewKeyboard is a keyboard for players without a physical one: touch screens, VR, kiosks, consoles with a pointer. Choose GameObject > Ultimate Web View > On-Screen Keyboard. With Auto Show on (the default) it appears when a text field of a web view takes focus and goes away when the field loses it. No code is needed.

Layouts. QWERTY (English, United States), AZERTY (French) and QWERTZ (German), each with its Shift and AltGr levels and its accent keys: press ^, then e, to type ê. A symbols page is the same for every layout. Number and telephone fields get a numeric pad. With Show Layout Key on, a key switches between the three layouts. Tap Shift for one capital, hold it or tap it twice to lock. Held keys repeat.

public sealed class KeyboardSetup : MonoBehaviour
{
    public WebViewKeyboard keyboard;
    public WebViewScreen screen;

    void Start()
    {
        keyboard.Layout = KeyboardLayoutType.Azerty;
        keyboard.HideOnEnter = true;
        keyboard.Shown += OnShown;
        keyboard.Hidden += OnHidden;

        // Serve one web view only. Leave Target null to serve whichever web view has focus.
        keyboard.Target = screen.WebView;
    }

    void OnShown()
    {
        Debug.Log("Keyboard up");
    }

    void OnHidden()
    {
        Debug.Log("Keyboard down");
    }
}

Show() and Hide() override the automatic behaviour until focus changes again. WebViewKeyboard.IsOpen is true while any on-screen keyboard is visible. The mode is set in the Inspector; it can't be changed from code.

While an On-Screen Keyboard component is enabled, phones and tablets keep their system keyboard closed. The keyboard serves web views that render to a texture; overlay web views (WebGL, native overlay on mobile) use the keyboard of the system or browser.

The keyboard in your own UI. KeyboardElement is the same keyboard as a UI Toolkit control. Put it anywhere in a layout, and use its events to type into your own text fields too:

var keys = new KeyboardElement();
keys.Layout = KeyboardLayoutType.Qwertz;
keys.style.height = 320f;
keys.TextEntered += OnText;         // Action<string>: text typed, accents combined
keys.KeyPressed += OnKey;           // Action<WebKey, KeyModifiers>: Backspace, Enter, Tab, arrows
keys.HideRequested += OnHide;       // the hide key; the element doesn't hide itself
root.Add(keys);

It types into the focused web view, or into Target when you set one, and never takes focus away from anything. In UXML it is <uwv:KeyboardElement layout="Azerty" show-hide-key="false" />, with the attributes layout, numeric-mode, show-layout-key, show-hide-key and light-theme.

Hardware keyboard and input systems

In play mode the physical keyboard types into the web view that has focus. A web view gets focus when it is clicked (PointerDown) or when you call Focus(); Blur() or a click outside takes it away. WebView.Focused is the web view that has it.

• Both input backends. The forwarder reads the Input System when the package is installed and active, otherwise the legacy Input Manager. You don't choose; it follows Active Input Handling in the Player settings.
• Your game still gets the keys. Nothing is consumed. Before you act on a key, check WebView.IsEditingText: it is true while the user types into a text field of a page.
• Layouts. Characters come from the operating system layout, AltGr combinations included. Shortcuts follow the printed letter: on an AZERTY keyboard Ctrl+A selects all.
• Your own key handling. Set webView.HardwareKeyboard = false and send keys yourself with KeyDown, KeyUp, SendKey and TypeText.

void Update()
{
    // Don't open the inventory while the player types "i" into a search box.
    if (WebView.IsEditingText) return;
    if (Input.GetKeyDown(KeyCode.I)) ToggleInventory();
}

TypeText sends characters found on a keyboard as real key presses, so pages that listen to key events react. Everything else (accents, emoji, other scripts) is inserted directly. The clipboard and undo commands are methods: Copy(), Cut(), Paste(), SelectAll(), Undo(), Redo(), DeleteSelection().

On phones and tablets, tapping a text field of a texture web view opens the system keyboard and types what the user enters into the page. Turn that off with the System keyboard setting, or enable an On-Screen Keyboard component, which takes over.

Popups, dialogs, downloads, permissions and errors

A game has no window manager, no download folder and no permission bar. Each of those browser features becomes an event you can handle, with a safe default when you don't.

void Wire(WebView webView)
{
    webView.PopupRequested += OnPopup;
    webView.DialogOpened += OnDialog;
    webView.DownloadRequested += OnDownload;
    webView.LoadFailed += OnLoadFailed;
}

// Needs options.popups = PopupMode.NotifyOnly.
void OnPopup(string url)
{
    Application.OpenURL(url);
}

void OnDialog(ScriptDialog dialog)
{
    if (dialog.Type == DialogType.Confirm)
    {
        // Show your own UI here and call Accept or Cancel when the player decides.
        dialog.Cancel();
        return;
    }
    dialog.Accept();
}

void OnDownload(DownloadRequest request)
{
    Debug.Log("The page offers " + request.suggestedFileName + " at " + request.url);
}

void OnLoadFailed(LoadError error)
{
    Debug.LogWarning(error.description + " (" + error.code + ")");
}

Always answer a ScriptDialog you receive: the page is paused until you do. Reload() after a failed load tries the address that failed, not the error page.

A transparent page as HUD

With transparent on, every part of a page that has no background shows what is behind it. That makes HTML and CSS usable for HUDs, menus and overlays.

1. Create a Web View Image that fills a Screen Space - Overlay canvas.
2. Turn on Options > Transparent.
3. Write the page without a background: html, body { background: transparent; margin: 0; }.
4. Load it from a TextAsset or from StreamingAssets, and exchange messages.

public sealed class Hud : MonoBehaviour
{
    public WebViewImage hud;      // Options > Transparent on, On Message wired to OnHudMessage
    public TextAsset page;

    [System.Serializable]
    sealed class HudState
    {
        public int health;
        public int ammo;
    }

    void Start()
    {
        hud.LoadHtml(page.text);
    }

    public void OnHudMessage(string message)
    {
        if (message == "pause") Time.timeScale = 0f;
        if (message == "resume") Time.timeScale = 1f;
    }

    public void Refresh(int health, int ammo)
    {
        var state = new HudState();
        state.health = health;
        state.ammo = ammo;
        hud.PostMessage(JsonUtility.ToJson(state));
    }
}

<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<style>
  html, body { background: transparent; margin: 0; font: 600 22px system-ui, sans-serif; color: #fff; }
  #bar { position: fixed; left: 24px; bottom: 24px; }
  button { position: fixed; right: 24px; top: 24px; }
</style>
</head>
<body>
  <div id="bar">Health <span id="health">100</span> &middot; Ammo <span id="ammo">0</span></div>
  <button onclick="uwv.postMessage('pause')">Pause</button>
  <script>
    uwv.addEventListener('message', function (e) {
      var state = JSON.parse(e.data);
      document.getElementById('health').textContent = state.health;
      document.getElementById('ammo').textContent = state.ammo;
    });
  </script>
</body>
</html>

Limits to plan for:

• Clicks don't pass through transparent areas. A full-screen WebViewImage receives every click on it, also where the page is see-through. For a HUD that only displays, turn Interactive off and clear Raycast Target on the RawImage. For a HUD with a few buttons, size the image to the area that holds them, or use two web views.
• Cost. A full-screen page at a high resolution is a large texture that is uploaded each time the page changes. Keep animations small, lower Frame Rate, or use Resolution Scale below 1. See section 8.
• Platforms. In WebGL builds the page is always above the canvas, which suits a HUD. On iOS, texture mode is slow for anything animated.

The scene 03 HTML HUD in the Demo folder is a working version of this recipe.

5Components

This section lists every Inspector field. The names are the labels you see in the Inspector. The matching script members are in section 10.

Shared fields and options

Web View Screen and Web View Image share these fields. Both create their web view when they are first enabled in play mode and dispose it when they are destroyed. Disabling the component keeps the web view and its page.

The fields of Options (the class WebViewOptions):

Web View Screen

Shows a page on a mesh. Add Component > Ultimate Web View > Web View Screen.

• The object needs a collider for WebViewPointer to hit. A MeshCollider gives exact results on curved or UV-mapped screens, if the mesh has Read/Write enabled.
• The texture is set on the renderer, so it reaches every material of a multi-material renderer that has the property. Give the screen its own renderer, or name a Texture Property that only the screen material has.
• With Render Mode on Native Overlay on a phone, the native view covers the rectangle that the screen occupies on the display. It can't be rotated or hidden behind other objects.

Web View Image

Shows a page in a uGUI RawImage and takes input from the EventSystem. Add Component > Ultimate Web View > Web View Image. The component exists when the Unity UI package is installed.

• The canvas needs a GraphicRaycaster and the scene an EventSystem, as for any interactive uGUI element.
• The image takes every click inside its rectangle, also where a transparent page shows nothing.
• On a touch screen, dragging scrolls the page.
• Rotating or masking the image works: the page is an ordinary texture. In Native Overlay mode (and in WebGL) the page is a rectangle above everything Unity draws.

Web View Pointer

Aims at WebViewScreens and at the world-space keyboard with a physics ray. Add Component > Ultimate Web View > Web View Pointer. One pointer serves every screen in the scene. Use several for several controllers.

The pointer also works with your own surfaces: anything that implements IWebViewPointerTarget on a GameObject with a collider receives moves, presses and scrolling.

Web View Audio

Plays the sound of one web view through the AudioSource on the same object. Add Component > Ultimate Web View > Web View Audio. Windows and Linux only.

The component has no fields of its own. Set up the AudioSource as for any sound: Spatial Blend, Volume, Output mixer group, roll-off. Leave AudioClip empty. On the same object as a WebViewScreen or WebViewImage it binds by itself; for other web views call Bind.

On-Screen Keyboard

The keyboard component, WebViewKeyboard. Add Component > Ultimate Web View > On-Screen Keyboard.

• The keyboard restyles through USS. Its class names are constants on KeyboardElement (uwv-keyboard, uwv-keyboard__key and so on); add your own style sheet to keyboard.Element.
• One keyboard is enough for a scene. In World mode, place the object where the player can reach it and give the pointer a line of sight to it.

6Settings

Project-wide settings are in Project Settings > Ultimate Web View (or Tools > HyTeKGames > Ultimate Web View > Settings). They are stored in Assets/Resources/UltimateWebViewSettings.asset, which is created the first time you change a value. Without the asset every setting keeps its default.

The Status card at the top shows whether the Windows and Linux engines are in the project, whether the engine runs in the Editor, and what the active build target supports. Its buttons Clear cookies and cache and Open profile folder act on the Editor profile.

Select the asset shows the settings asset in the Project window. Reset to defaults puts every value back. From code, UltimateWebViewSettings.Instance gives you the same object; change it before the first web view is created (or before WebView.Prewarm()) for the change to count.

7Platforms

The C# API is the same everywhere, but four different engines sit behind it, and they can't all do the same things. This section says what each one does and where it stops. If a feature matters to your game, check its row before you build on it.

Feature comparison

Windows

How it works. The package ships Chromium 156 through the Chromium Embedded Framework (CEF). The engine runs in a helper process, UltimateWebViewHost.exe, started by the first web view. Each page is rendered off-screen. Finished frames reach Unity through shared memory and are uploaded into a Texture2D; input, navigation and JavaScript travel over a local connection between the two processes. Page sound is captured by the engine and played by Unity. A crash inside a page or the engine can't take your game down, and the helper stops when the game stops, however it ends.

Limits.

• H.264, AAC and HEVC only with the codec setting. The standard engine is the stock Chromium build: WebM with VP8, VP9 or AV1 video and Opus or Vorbis sound plays, as do Ogg, WAV, FLAC and MP3 audio. MP4 files with H.264 or AAC, HLS streams and sites that only offer such streams, Twitch among them, don't. Turn on H.264, AAC and HEVC to use the engine build that plays them; HEVC also needs Hardware acceleration and a GPU that decodes it. The patent licences these codecs may need are your responsibility. With the setting off, encode your own videos as WebM.
• DRM plays protected audio, not protected video. With DRM (Widevine) on, the engine downloads Google's Widevine module from Google's update servers when it starts. Protected audio then plays. Protected video plays its sound, but its picture stays black: Chromium keeps decrypted frames out of off-screen rendering, and that is how the engine fills the texture, with or without hardware acceleration. On Windows, Netflix, Disney+, Prime Video and similar services also demand a browser signed through Widevine's certification (VMP), which no custom Chromium build has, and refuse to play at all.
• 60 frames per second at most, and frames cross process and CPU memory on their way to the GPU. A page is a browser, not a video player tuned for 4K.
• Size. About 335 MB on disk, most of it one library. See section 9.
• The helper is not code-signed. Antivirus software and Windows SmartScreen judge an unsigned program by reputation. If you sign your game, sign UltimateWebViewHost.exe in your build as well.
• The Chromium sandbox is on. The processes that run page content are locked down as in a desktop browser. The launcher UltimateWebViewHost.exe is the bootstrap program of the Chromium Embedded Framework and loads UltimateWebViewHost.dll; keep the two together. The setting Sandbox turns it off.
• No windows from pages. Popups, file choosers, print dialogs and context menus never open. Popups follow WebViewOptions.popups; a page that asks for a file gets none.
• No 32-bit and no ARM64 builds. Web views stay blank there and the build logs a warning.

Linux

How it works. The same engine and the same architecture as on Windows: Chromium 156, a helper process (UltimateWebViewHost), shared memory for frames and sound.

Limits. Everything listed for Windows applies, apart from code signing. In addition:

• The helper needs its executable permission. The package sets it each time it starts the engine, which fails when the game is installed in a folder it can't write to. Package Linux builds in a format that keeps permissions (.tar.gz).
• Chromium's local network access check stays on (only the Windows engine switches it off). A page loaded with LoadHtml and the default base address can be refused when it calls a server on the local network. Pass the address of that server as the base address. See HTML strings.
• The Chromium sandbox is off on Linux: page processes run with the rights of the game. Show content you trust, or content from the open web that you would also open in a browser at your own risk.
• With DRM (Widevine) on, a Widevine module the engine has just downloaded works from the next engine start on: Linux loads it while the engine starts. With the setting off, a module downloaded earlier stays unused.
• HEVC has no software decoder in Chromium. On Linux it needs hardware decoding through VA-API, which depends on the GPU and its driver, and it hasn't been tested there. H.264 and AAC play without it.
• ARM64 Linux is not supported.

Unity Editor

How it works. The Windows and Linux Editors use the desktop engine, whatever the active build target is. You see Chromium in the Editor even when the target is Android, iOS or WebGL; the device will use its own engine, so test there before you trust a layout or a video.

• Edit mode and play mode. WebView, WebViewElement and the Browser window work without entering play mode. The components create their web view in play mode only.
• Engine copy. The Editor runs the engine from Library/UltimateWebView, copied once per project and again when the package is updated.
• Script reloads. The engine stops at every script reload and starts again on demand. Components restore their page after a reload in play mode. Web views created in play mode are disposed when play mode ends. The engine itself stays warm between play sessions, so the second Play is fast.
• Enter Play Mode Options. Disabled domain and scene reload are supported.
• Sound. Page sound goes through Unity audio in play mode. Edit-mode web views play through the system output.
• Profile. Library/UltimateWebView/Profile, separate for every project and never part of a build.

Limits. The macOS Editor uses WebKit instead of Chromium, as a preview: see macOS. Linux and Windows Editors on ARM processors are not supported.

Android

How it works. The package uses the Android System WebView, the Chromium-based component every Android device has and updates through the Play Store. Two modes exist, chosen with Options > Render Mode:

• Texture (the default). The WebView is kept off-screen and its drawing is captured through a hardware canvas into a Unity texture. Pages show on 3D objects and in UI like on desktop, with video and WebGL.
• Native Overlay. The WebView is a native view on top of the Unity view, placed over the rectangle of your component. It is the device's browser view as it is: its own scrolling, text selection, pickers and keyboard.

In texture mode the size of the page comes from the texture, not from the phone: a page is as many CSS pixels wide as the texture divided by Pixel Density, whatever the density of the display. A 1280 pixel wide screen with Pixel Density 1 gets the desktop layout of a site, as on Windows; raise the density to 2 or 3 for larger text and the phone layout.

What the build step does. When you build for Android, the package edits the generated manifest (not your project files):

• adds the INTERNET permission;
• sets hardwareAccelerated="true" on the application and its activities, which the texture capture needs;
• sets usesCleartextTraffic="true" so http:// pages load, unless your manifest already sets that attribute or has a networkSecurityConfig;
• with Camera and microphone on, adds CAMERA, RECORD_AUDIO and MODIFY_AUDIO_SETTINGS;
• adds keep rules so code shrinking doesn't remove the package's Java classes.

The manifest entries don't grant the camera or the microphone. Android asks the user at run time, and your app has to make that request before the page does:

// Android only. Wrap in #if UNITY_ANDROID in a multi-platform project.
using UnityEngine.Android;

if (!Permission.HasUserAuthorizedPermission(Permission.Camera))
    Permission.RequestUserPermission(Permission.Camera);
if (!Permission.HasUserAuthorizedPermission(Permission.Microphone))
    Permission.RequestUserPermission(Permission.Microphone);

Limits in both modes.

• Sound plays through Android's own output, not through Unity audio: no WebViewAudio, no 3D sound, no mixer. Muted works. IsPlayingAudio and AudioStateChanged don't report.
• One cookie store per app. incognito is ignored. With Persistent storage off, cookies, storage and cache are cleared when the first web view is created, and that affects every WebView in the app, those of advertising or login SDKs included.
• Cookies API. GetCookies returns names and values only (no domain, path, expiry or flags). DeleteCookies removes cookies with the path /.
• Request headers passed to LoadUrl are sent with the main request only, not with redirects or sub-resources.
• File chooser requests (<input type="file">) are always cancelled.
• No fullscreen video, no WebXR, no geolocation.
• Ignore certificate errors only takes effect in development builds.
• The engine version is the device's. Old devices with an outdated WebView may lack newer web features. WebView.EngineVersion is empty on Android.

Limits of texture mode.

• CSS pixels follow the screen density. pixelDensity is ignored; a 1280 pixel wide texture on a dense phone gives a narrow layout. Use Zoom (applied as CSS zoom) or a viewport meta tag to tune it.
• Textures are capped at 4096 pixels per side.
• Left button and touch only. No right or middle button, and no cursor shape events.
• Native popups don't show. The lists of <select> elements, date pickers and other controls that Android draws in its own windows aren't part of the page drawing. Use HTML controls in pages meant for texture mode.

Limits of overlay mode.

• The page is always above everything Unity draws. Unity UI can't sit on top of it.
• It is an axis-aligned rectangle: no rotation, no perspective, no masks, no 3D.
• It isn't part of the rendered image, so it doesn't work in VR.
• Unity receives no touches inside it, and the on-screen keyboard component doesn't serve it.

iOS

How it works. The package uses WKWebView, the only browser engine iOS offers to apps. Two modes exist:

• Texture (the default). The web view is kept off-screen. The package takes snapshots of it and uploads them into a Unity texture, and replays your pointer and keyboard input in the page with JavaScript, because iOS has no way to send synthetic touches to a view.
• Native Overlay. The WKWebView is placed on top of the Unity view. Full speed, real touch input, video, the system keyboard.

Limits of texture mode.

• About 10 to 30 frames per second, depending on the device and the size of the texture. Taking a snapshot costs time on the main thread, so a page that animates all the time lowers the frame rate of the game. Keep textures small and lower Frame Rate.
• HTML5 video is not visible in the texture; its sound plays. The same goes for DRM video. Use Native Overlay.
• WebGL canvases may be missing from the snapshots.
• Input is simulated. Events created by script have isTrusted false. Sites that check it (some login pages, payment forms, captchas) reject the input. The CSS states :hover and :active don't follow the pointer. HTML5 drag and drop and selecting text by dragging don't work.
• No text caret and no selection highlight are drawn. Typing works; you don't see where the caret is.
• No IME composition and no autofill. Chinese, Japanese and Korean input methods can't compose into the page.
• <select> elements are shown as a list inside the page instead of the iOS picker. Date, time and colour inputs are not supported.
• Before iOS 14, frames that show another site (an embedded video player, a payment widget) don't receive input, and copying text from the page to the clipboard is off. From iOS 14 on both work.

Limits in both modes.

• Sound plays through iOS, not through Unity audio: no WebViewAudio, no 3D sound. Muted is best effort: it silences media elements the package can reach from script. IsPlayingAudio and AudioStateChanged don't report.
• Downloads are reported through DownloadRequested and never saved.
• Request headers passed to LoadUrl are sent with the first main request only.
• Ignore certificate errors only takes effect in development builds.
• Engine. Every iOS browser engine is WebKit. Pages that only work in Chromium won't work here. WebView.EngineVersion is empty on iOS.

Limits of overlay mode. As on Android: always above Unity, an axis-aligned rectangle, and Unity gets no input inside it. Elements can go fullscreen from iOS 15.4.

macOS

How it works. On macOS 11 or later the package uses WKWebView, the engine of Safari, through the plugin Runtime/MacOS/UltimateWebViewMac.dylib (Intel and Apple Silicon in one file). It shares its code with iOS and behaves the same way, in builds and in the Editor:

• Texture (the default). The web view sits invisibly inside the game window, snapshots of it are uploaded into a Unity texture, and your pointer and keyboard input is replayed in the page with JavaScript.
• Native Overlay. The WKWebView is placed on top of the game view, with the real mouse and keyboard. In the Editor the overlay is not lined up with the Game view; use it in builds.

Limits. Those of iOS: texture mode suits pages that are mostly still (about 10 to 30 frames per second, no video), simulated input has no hover styles, drag and drop or IME composition, and page sound plays through the system instead of Unity audio. Chromium is not used on macOS, so DevTools, extra engine arguments, hardware acceleration and the sandbox setting don't apply; Safari's Web Inspector attaches to development builds on macOS 13.3 or later. An older macOS can't load the plugin: WebView.IsSupported is false there and web views stay blank.

Signing. The library is signed ad hoc. When you sign and notarise your game, sign it together with the rest of the app, as you do for every other plugin.

WebGL

How it works. A game in a browser can't embed a second browser, and browsers don't let a page read the pixels of another site. So in WebGL builds a web view is an <iframe> that the package creates next to the Unity canvas and keeps positioned over the rectangle of your component, in perspective when the component is a tilted WebViewScreen. The player's own browser renders it and handles its input.

What that means.

• Overlay only. RendersToTexture is false and Texture stays empty. The page is always above the canvas: Unity UI, 3D objects and post-processing can't cover or affect it. A screen behind a wall still shows its page, so hide such screens yourself (disable the component).
• Sites can refuse. Many sites forbid being shown in a frame (X-Frame-Options, Content-Security-Policy: frame-ancestors). They report LoadFailed with code -27. Search engines, social networks, banks and most login pages are among them. Your own pages and pages made for embedding work.
• https games need https pages. A game served over https can't show an http:// page, except from localhost.
• Only web addresses. http, https, about, data and blob addresses load. streaming-assets:// addresses resolve to the StreamingAssets folder next to the build on your web server.

Same origin and other origins. A page served from the same origin as the game (same scheme, host and port), a StreamingAssets page or a LoadHtml page is fully scriptable. For pages of other origins the browser draws a hard line:

A page of another origin that you control can still exchange messages with the game. It uses the browser's own postMessage:

// In the page (other origin). Page to Unity: arrives in WebView.MessageReceived.
window.parent.postMessage({ uwvMessage: 'hello from the page' }, '*');

// Unity to page: what WebView.PostMessage sends.
window.addEventListener('message', function (e) {
    if (e.data && e.data.uwvMessage !== undefined) console.log(e.data.uwvMessage);
});

Other limits.

• Pointer and keyboard input belong to the browser. PointerMove, PointerDown, PointerUp and Click do nothing, the pointer and keyboard components don't serve iframes, and Unity gets no input while the mouse is over the page.
• WebViewData does nothing: cookies and storage belong to the player's browser. Third-party cookie rules of that browser apply to pages in frames.
• No dialog, download, popup, cursor or crash events. LoadUrl headers are ignored. FrameRate is ignored.
• No Unity audio. Sound plays in the browser, under its autoplay rules.
• The iframe follows the canvas. Custom HTML templates that transform or reparent the canvas can misplace it; keep the canvas in a positioned container.

8Performance

A web view costs in three places: the browser engine renders the page, the finished frame is copied to Unity, and Unity uploads it to the GPU. The first cost depends on the page, the other two on the number of pixels and on how often the page changes. A page that doesn't change costs nothing per frame.

Start-up. The engine starts with the first web view. On Windows and Linux that takes about a second, during which the texture is empty. Call WebView.Prewarm() in a loading screen, or create the web view early and show it when LoadFinished arrives.

A screen in the distance. A 1280 pixel wide texture on a monitor that covers 200 pixels of the view wastes most of its pixels. Lower the resolution, turn on Mip Maps if the text shimmers, and turn on Pause When Not Visible.

A full-screen HUD. At 1920 x 1080 every repaint is 8 MB. Keep the page still between updates: change text and numbers when the game state changes instead of animating them every frame. If only a corner of the HUD is animated, give it its own small web view.

Mobile. On Android, texture capture runs on the GPU and is fast, but the copy to Unity still depends on the size. On iOS, texture mode is slow by design of the platform: keep textures small, cap the frame rate at 15 to 30, and switch to Native Overlay for anything that moves a lot.

Memory. The engine on Windows and Linux uses a few hundred megabytes of RAM once pages are open, more with heavy sites. That memory belongs to the helper processes and doesn't show in Unity's profiler. Budget for it on machines with little RAM.

9Building and shipping

Builds need no manual step. This section says what the package adds to each build, what it costs in size, and what to check before release.

Windows and Linux builds

After Unity has built a Windows x64 or Linux x64 player, a build step copies the engine next to it:

MyGame.exe
MyGame_Data/
    UltimateWebView/
        UltimateWebViewHost.exe      the helper process (UltimateWebViewHost on Linux)
        libcef.dll                   Chromium (libcef.so on Linux)
        chrome_elf.dll, d3dcompiler_47.dll, vk_swiftshader.dll, vulkan-1.dll
        icudtl.dat, v8_context_snapshot.bin, vk_swiftshader_icd.json
        resources.pak, chrome_100_percent.pak, chrome_200_percent.pak
        locales/en-US.pak

• Ship the whole folder. Every file is needed. Installers, launchers and store uploads must keep MyGame_Data/UltimateWebView as it is.
• The source is the Engine folder of the package: Engine/Windows/x86_64 or Engine/Linux/x86_64. The build step renames the helper from UltimateWebViewHost.uwv to its real name.
• Cross-building works. You can build the Linux player from the Windows Editor and the other way round.
• Custom build pipelines. If the step can't find the data folder of the build, it logs a warning that names the folder to copy. Copy it to <Game>_Data/UltimateWebView yourself and rename the helper.
• 32-bit Windows builds get no engine and log 32-bit Windows players are not supported. Web views stay blank in this build; switch the architecture to x86-64.
• One engine per build. If you only target one desktop platform and never open the project in the Editor of the other, you can delete the other platform's folder from Engine. The Status card of the settings page shows which engines are present.

Licence files. The engine is open-source software, and its licences ask that their text travels with the binaries. The build step copies CEF_LICENSE.txt and Chromium_CREDITS.html into MyGame_Data/UltimateWebView/Licenses of every Windows and Linux build. Leave them there when you package the game; you can also show them behind a button in your credits. See section 12.

Code signing. The helper isn't signed. If you sign your Windows build, sign MyGame_Data/UltimateWebView/UltimateWebViewHost.exe with the same certificate. The Chromium libraries can stay as they are.

Player data. At run time the engine writes its profile to UltimateWebView in Application.persistentDataPath. Nothing is written into the game folder.

Android, iOS and WebGL builds

These builds contain no browser engine, only the bridge to the one on the device.

The Engine folder is never part of an Android, iOS or WebGL build.

Size and version control

The engine compresses to less than half: about 160 MB for Windows and 140 MB for Linux in a zip archive, and similar in a store download.

Version control. libcef.dll and libcef.so are larger than the 100 MB per-file limit of GitHub and of several other hosts. Track the engine with Git LFS:

# .gitattributes
Assets/HyTeKGames/UltimateWebView/Engine/** filter=lfs diff=lfs merge=lfs -text

If you never turn on H.264, AAC and HEVC, you can delete the two Codecs folders. The settings page then warns you if the setting is switched on.

The alternative is to keep the Engine folder out of the repository and import it from the package on each machine. The scripts compile without it; web views stay blank and the Console says the engine is missing. Plastic SCM and Perforce handle the files as they are.

Before you ship

1. Test on the real target. The Editor always shows Chromium; Android, iOS and WebGL use other engines with other limits.
2. Set Remote debugging port to 0 and turn Ignore certificate errors off. Remove development switches from Extra engine arguments.
3. Decide what your game does when a page fails to load (offline players): keep the built-in error page, or handle LoadFailed.
4. Decide what popups and downloads do: see section 4.
5. Windows and Linux: add the two licence files to the build and credit the Chromium Embedded Framework. Sign the helper if you sign the game.
6. Windows and Linux: check your videos. MP4 with H.264 plays only with H.264, AAC and HEVC on, and then you are responsible for the patent licences; WebM always plays.
7. Android and iOS: request camera and microphone permissions and fill in the usage descriptions, if pages use them.
8. If your pages show content from the open web, say so in your store listing and privacy policy where the store asks for it. The package itself collects nothing and contacts no server of its own. With DRM (Widevine) on, the engine contacts Google's component update servers to get and update the Widevine module.

10Scripting reference

Every public type of the package, with every public member. All types are in the namespace HyTeKGames.UltimateWebView and in the assembly of the same name. Call everything from the main thread; every event and callback is raised there.

WebView

public sealed class WebView : IDisposable. A web page rendered by the browser engine of the platform. Points are normalised, (0, 0) top-left and (1, 1) bottom-right. Calls made before IsReady are queued and replayed.

Constructors

Static members

Properties

Events

Navigation

Size and overlay

The components and WebViewElement call the overlay methods for you. You need them only for a WebView you manage yourself.

JavaScript

Pointer

Keyboard and editing

WebViewOptions

[Serializable] public sealed class WebViewOptions. Read once when a web view is created. The Inspector shows these fields under Options.

Data types

ScriptDialog

public sealed class ScriptDialog. A JavaScript dialog waiting for an answer. Passed to WebView.DialogOpened.

LoadError

public struct LoadError. Passed to WebView.LoadFailed.

ConsoleMessage

public struct ConsoleMessage. Passed to WebView.ConsoleMessage.

InputFocus

public struct InputFocus. The text field that has focus inside a page.

DownloadRequest

public struct DownloadRequest. Passed to WebView.DownloadRequested.

WebCookie

[Serializable] public struct WebCookie.

WebViewException

public sealed class WebViewException : Exception. Thrown by EvaluateJavaScriptAsync when the script fails. Message holds the JavaScript error. Constructor: WebViewException(string message).

WebViewData

public static class WebViewData. Cookies and stored data of the browser profile that all web views share. Does nothing in WebGL builds.

UltimateWebViewSettings

public sealed class UltimateWebViewSettings : ScriptableObject. The project-wide settings of section 6. They are read when the browser engine starts.

Components

WebViewComponent

public abstract class WebViewComponent : MonoBehaviour. The base of WebViewScreen and WebViewImage: owns a WebView, keeps its size up to date and raises the Inspector events. Derive from it to show a web view on something else.

Protected members, for your own display components:

WebViewScreen

public sealed class WebViewScreen : WebViewComponent, IWebViewPointerTarget. A page on a mesh. Inherits everything above.

WebViewImage

public sealed class WebViewImage : WebViewComponent, with the EventSystem interfaces IPointerEnterHandler, IPointerExitHandler, IPointerDownHandler, IPointerUpHandler, IScrollHandler, IBeginDragHandler, IDragHandler, IEndDragHandler, ISelectHandler and IDeselectHandler. A page in a uGUI RawImage. Only compiled when the Unity UI package is installed.

WebViewPointer

public sealed class WebViewPointer : MonoBehaviour. Aims at pointer targets with a physics ray.

WebViewAudio

public sealed class WebViewAudio : MonoBehaviour. Requires an AudioSource. Windows and Linux.

IWebViewPointerTarget

public interface IWebViewPointerTarget. A surface a WebViewPointer can aim at. Implement it on a component whose GameObject has a collider. WebViewScreen and WebViewKeyboard implement it.

WebViewCursors

public static class WebViewCursors. The cursor images the package draws, 32 x 32 pixels, for use with UnityEngine.Cursor.SetCursor or in your own UI.

WebViewStringEvent

[Serializable] public sealed class WebViewStringEvent : UnityEvent<string>. The type of the On Page Loaded and On Message events in the Inspector.

WebViewElement

public partial class WebViewElement : VisualElement. A web view as a UI Toolkit element. UXML name WebViewElement in the namespace HyTeKGames.UltimateWebView. Runtime panels need Unity 2021.2 or newer.

Before Unity 2023.2 the class also contains the nested types UxmlFactory and UxmlTraits, which UI Builder and UXML need. From 2023.2 on the element uses [UxmlElement] instead.

Keyboard

WebViewKeyboard

public sealed class WebViewKeyboard : MonoBehaviour, IWebViewPointerTarget. The on-screen keyboard component.

KeyboardElement

public partial class KeyboardElement : VisualElement. The keyboard as a UI Toolkit control, for your own layouts. It types into the focused web view (or Target) and raises events for other uses. It never takes focus. UXML name KeyboardElement in the namespace HyTeKGames.UltimateWebView.

Before Unity 6 the class also contains the nested types UxmlFactory and UxmlTraits.

Enums

JavaScript side

The object window.uwv exists in every page a web view loads (in WebGL builds: in pages of the game's origin).

The package also defines window.__uwvPost and a few other names starting with __uwv for its own use. Don't call or overwrite them.

11Troubleshooting and FAQ

Start with the Console. The package prefixes its messages with [Ultimate Web View] and says what is wrong and what to do. For more detail, set Engine log level to Everything and turn on Page console to Unity console in the settings.

12Third-party software

The scripts, shaders, style sheets, the Android, iOS and WebGL plugins and the helper program are written by HyTeKGames and licensed under the Unity Asset Store EULA. The browser engine for Windows and Linux in the Engine folder is open-source software with its own licences. The package contains no third-party fonts, images, sounds or script libraries.

The details are in three files of the package:

• Third-Party Notices.txt: every component with its version, copyright holder, licence and source address.
• Licenses/CEF_LICENSE.txt: the licence of the Chromium Embedded Framework.
• Licenses/Chromium_CREDITS.html: the complete list of the components inside Chromium with every licence text, as generated by the Chromium build.

What this means for your game. Windows and Linux builds contain these binaries. The build step puts CEF_LICENSE.txt and Chromium_CREDITS.html into MyGame_Data/UltimateWebView/Licenses; keep that folder in what you ship. Android, iOS and WebGL builds contain none of these components and need no notice.

About the LGPL parts. The LGPL code is inside libcef, a separate dynamic library that only the helper process loads. It isn't linked into your game or into the scripts of this package. You or your players may replace libcef and the files that belong to it with another build of the same CEF version, in the Engine folder before building or in <Game>_Data/UltimateWebView afterwards. The source code is available at the addresses listed in Third-Party Notices.txt.

13Support and changelog

Support

A report I can act on contains:

• the Unity version, the render pipeline and the package version (WebView.Version);
• the platform where it happens: Editor or build, operating system, device model for mobile;
• what you did, what you expected and what happened, with the address of the page if it is public;
• the Console messages that start with [Ultimate Web View];
• for engine problems on Windows and Linux, the file Logs/UltimateWebViewHost.log, written when Engine log level is Everything.

If the package is useful to you, a review on the Asset Store helps other developers find it. Thank you!

Changelog

1.1.0

• Added – H.264, AAC and HEVC setting (Windows, Linux, off by default): switches to an engine build that plays MP4 files, HLS streams and known livestream sites. HEVC also plays on Windows when Hardware acceleration is on. Builds stay the same size; the package grows by 326 MB for Windows and 307 MB for Linux.
• Added – DRM (Widevine) setting: the engine downloads the Widevine module when it starts. On desktop, protected audio plays; protected video plays its sound but its picture stays black. Known streaming movie sites refuse on Windows.
• Added – inspector warning: Web View Screen and Web View Image warn when the address is a known livestream or video site that needs H.264, or an MP4 or HLS address, and the codecs are off. An Open Settings button opens the settings page.
• Fixed – Linux DRM off: a Widevine module downloaded earlier is no longer loaded while DRM is off.
• Docs: the documentation, store page and third-party notices now cover the patents and the new sizes.

1.0.0

First release.

• WebView scripting API: navigation, pointer and keyboard input, JavaScript, messaging, cookies and stored data.
• Display components: WebViewScreen for meshes, WebViewImage for uGUI, WebViewElement for UI Toolkit.
• WebViewPointer with mouse, screen centre, transform and virtual cursor modes.
• On-screen keyboard with QWERTY, AZERTY and QWERTZ layouts, in overlay and world modes.
• Page sound through Unity audio on Windows and Linux, with WebViewAudio for 3D sound.
• Engines: Chromium 156 for Windows x64, Linux x64 and the Editor on both, sandboxed on Windows; Android System WebView; WKWebView on iOS and, as a preview, on macOS; iframe overlay in WebGL.
• Editor: Welcome window, Browser window, settings page, build steps for Windows, Linux, Android and iOS.
• Four demo scenes for the Built-in pipeline, URP and HDRP.