wry

[](https://docs.rs/wry/) Wry is a cross-platform WebView rendering library. The webview requires a running event loop and a window type that implements [`HasWindowHandle`], or a gtk container widget if you need to support X11 and Wayland. You can use a windowing library like [`tao`] or [`winit`]. ### Examples This example leverages the [`HasWindowHandle`] and supports Windows, macOS, iOS, Android and Linux (X11 Only). See the following example using [`winit`]: ``` … ``` If you also want to support Wayland too, then we recommend you use [`WebViewBuilderExtUnix::build_gtk`] on Linux. See the following example using [`tao`]: ```rust let event_loop = EventLoop::new(); let window = WindowBuilder::new().build(&event_loop).unwrap(); let builder = WebViewBuilder::new().with_url("https://tauri.app"); #[cfg(not(target_os = "linux"))] let webview = builder.build(&window).unwrap(); #[cfg(target_os = "linux")] let webview = builder.build_gtk(window.gtk_window()).unwrap(); ``` ### Child webviews You can use [`WebViewBuilder::build_as_child`] to create the webview as a child inside another window. This is supported on macOS, Windows and Linux (X11 Only). ``` … ``` If you want to support X11 and Wayland at the same time, we recommend using [`WebViewExtUnix::new_gtk`] or [`WebViewBuilderExtUnix::build_gtk`] with [`gtk::Fixed`]. ``` … ``` ### Platform Considerations Here is the underlying web engine each platform uses, and some dependencies you might need to install. #### Linux [WebKitGTK](https://webkitgtk.org/) is used to provide webviews on Linux which requires GTK, so if the windowing library doesn't support GTK (as in [`winit`]) you'll need to call [`gtk::init`] before creating the webview and then call [`gtk::main_iteration_do`] alongside your windowing library event loop. ``` … ``` ##### Linux Dependencies ###### Arch Linux / Manjaro: ```bash sudo pacman -S webkit2gtk-4.1 ``` ###### Debian / Ubuntu: ```bash sudo apt install libwebkit2gtk-4.1-dev ``` ###### Fedora ```bash sudo dnf install gtk3-devel webkit2gtk4.1-devel ``` ###### Nix & NixOS ```nix # shell.nix let # Unstable Channel | Rolling Release pkgs = import (fetchTarball("channel:nixpkgs-unstable")) { }; packages = with pkgs; [ pkg-config webkitgtk_4_1 ]; in pkgs.mkShell { buildInputs = packages; } ``` ```sh nix-shell shell.nix ``` ###### GUIX ```scheme ;; manifest.scm (specifications->manifest '("pkg-config" ; Helper tool used when compiling "webkitgtk" ; Web content engine fot GTK+ )) ``` ```bash guix shell -m manifest.scm ``` #### macOS WebKit is native on macOS so everything should be fine. If you are cross-compiling for macOS using [osxcross](https://github.com/tpoechtrager/osxcross) and encounter a runtime panic like `Class with name WKWebViewConfiguration could not be found` it's possible that `WebKit.framework` has not been linked correctly, to fix this set the `RUSTFLAGS` environment variable: ```bash RUSTFLAGS="-l framework=WebKit" cargo build --target=x86_64-apple-darwin --release ``` #### Windows WebView2 provided by Microsoft Edge Chromium is used. So wry supports Windows 7, 8, 10 and 11. #### Android In order for `wry` to be able to create webviews on Android, there are a few requirements that your application needs to uphold: 1. You need to set a few environment variables that will be used to generate the necessary kotlin files that you need to include in your Android application for wry to function properly. - `WRY_ANDROID_PACKAGE`: which is the reversed domain name of your android project and the app name in snake_case, for example, `com.wry.example.wry_app` - `WRY_ANDROID_LIBRARY`: for example, if your cargo project has a lib name `wry_app`, it will generate `libwry_app.so` so you set this env var to `wry_app` - `WRY_ANDROID_KOTLIN_FILES_OUT_DIR`: for example, `path/to/app/src/main/kotlin/com/wry/example` 2. Your main Android Activity needs to inherit `AppCompatActivity`, preferably it should use the generated `WryActivity` or inherit it. 3. Your Rust app needs to call `wry::android_setup` function to setup the necessary logic to be able to create webviews later on. 4. Your Rust app needs to call `wry::android_binding!` macro to setup the JNI functions that will be called by `WryActivity` and various other places. It is recommended to use the [`tao`](https://docs.rs/tao/latest/tao/) crate as it provides maximum compatibility with `wry`. ```rust #[cfg(target_os = "android")] { tao::android_binding!( com_example, wry_app, WryActivity, wry::android_setup, // pass the wry::android_setup function to tao which will be invoked when the event loop is created _start_app ); wry::android_binding!(com_example, ttt); } ``` If this feels overwhelming, you can just use the preconfigured template from [`cargo-mobile2`](https://github.com/tauri-apps/cargo-mobile2). For more information, check out [MOBILE.md](https://github.com/tauri-apps/wry/blob/dev/MOBILE.md). ### Feature flags Wry uses a set of feature flags to toggle several advanced features. - `os-webview` (default): Enables the default WebView framework on the platform. This must be enabled for the crate to work. This feature was added in preparation of other ports like cef and servo. - `x11` (default): Enables x11 support and dependencies on Linux. - `serde`: Enables `dpi`'s `serde` feature. - `devtools`: Enables devtools on release builds. Devtools are always enabled in debug builds. On **macOS**, enabling devtools, requires calling private APIs so you should not enable this flag in release build if your app needs to publish to App Store. - `mac-proxy`: Enables `WebViewBuilder::with_proxy_config` on macOS. - `linux-body`: Enables body support of custom protocol request on Linux. Requires WebKit2GTK v2.40 or above. - `tracing`: enables [`tracing`] for `evaluate_script`, `ipc_handler`, and `custom_protocols`. ### Partners For the complete list of sponsors please visit our [website](https://tauri.app#sponsors) and [Open Collective](https://opencollective.com/tauri). ### License Apache-2.0/MIT [`tao`]: https://docs.rs/tao [`winit`]: https://docs.rs/winit [`tracing`]: https://docs.rs/tracing