https://github.com/tauri-apps/wry
Cross-platform WebView library in Rust for Tauri.
https://github.com/tauri-apps/wry
Last synced: 6 months ago
JSON representation
Cross-platform WebView library in Rust for Tauri.
- Host: GitHub
- URL: https://github.com/tauri-apps/wry
- Owner: tauri-apps
- License: apache-2.0
- Created: 2020-07-12T15:12:44.000Z (over 5 years ago)
- Default Branch: dev
- Last Pushed: 2025-05-02T15:29:56.000Z (6 months ago)
- Last Synced: 2025-05-12T02:46:13.168Z (6 months ago)
- Language: Rust
- Homepage:
- Size: 9.09 MB
- Stars: 4,097
- Watchers: 40
- Forks: 330
- Open Issues: 121
-
Metadata Files:
- Readme: README.md
- Changelog: CHANGELOG.md
- Funding: .github/FUNDING.yml
- License: LICENSE-APACHE
- Code of conduct: .github/CODE_OF_CONDUCT.md
- Audit: audits/Radically_Open_Security-v1-report.pdf
- Codeowners: .github/CODEOWNERS
- Security: SECURITY.md
Awesome Lists containing this project
- awesome-rust - tauri-apps/wry - Webview Rendering librarY. (Libraries / GUI)
- awesome-rust-cn - tauri-apps/wry - Webview渲染库. (库 Libraries / GUI GUI)
- awesome-list - wry - platform WebView library in Rust for Tauri. | tauri-apps | 471 | (Rust)
- awesome-code-for-gamedev - wry - Cross-platform WebView rendering librarythat supports all major desktop platforms like Windows, macOS, and Linux. (WebView / ORM)
README
[](https://crates.io/crates/wry) [](https://docs.rs/wry/)
[](https://opencollective.com/tauri)
[](https://discord.gg/SpmNs4S)
[](https://tauri.app)
[](https://good-labs.github.io/greater-good-affirmation)
[](https://opencollective.com/tauri)
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`]:
```rust
#[derive(Default)]
struct App {
window: Option,
webview: Option,
}
impl ApplicationHandler for App {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
let window = event_loop.create_window(Window::default_attributes()).unwrap();
let webview = WebViewBuilder::new()
.with_url("https://tauri.app")
.build(&window)
.unwrap();
self.window = Some(window);
self.webview = Some(webview);
}
fn window_event(&mut self, _event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {}
}
let event_loop = EventLoop::new().unwrap();
let mut app = App::default();
event_loop.run_app(&mut app).unwrap();
```
If you also want to support Wayland too, then we recommend you use [`WebViewBuilderExtUnix::new_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 [`WebView::new_as_child`] or [`WebViewBuilder::new_as_child`] to create the webview as a child inside another window. This is supported on
macOS, Windows and Linux (X11 Only).
```rust
#[derive(Default)]
struct App {
window: Option,
webview: Option,
}
impl ApplicationHandler for App {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
let window = event_loop.create_window(Window::default_attributes()).unwrap();
let webview = WebViewBuilder::new()
.with_url("https://tauri.app")
.with_bounds(Rect {
position: LogicalPosition::new(100, 100).into(),
size: LogicalSize::new(200, 200).into(),
})
.build_as_child(&window)
.unwrap();
self.window = Some(window);
self.webview = Some(webview);
}
fn window_event(&mut self, _event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {}
}
let event_loop = EventLoop::new().unwrap();
let mut app = App::default();
event_loop.run_app(&mut app).unwrap();
```
If you want to support X11 and Wayland at the same time, we recommend using
[`WebViewExtUnix::new_gtk`] or [`WebViewBuilderExtUnix::new_gtk`] with [`gtk::Fixed`].
```rust
let event_loop = EventLoop::new();
let window = WindowBuilder::new().build(&event_loop).unwrap();
let builder = WebViewBuilder::new()
.with_url("https://tauri.app")
.with_bounds(Rect {
position: LogicalPosition::new(100, 100).into(),
size: LogicalSize::new(200, 200).into(),
});
#[cfg(not(target_os = "linux"))]
let webview = builder.build_as_child(&window).unwrap();
#[cfg(target_os = "linux")]
let webview = {
# use gtk::prelude::*;
let vbox = window.default_vbox().unwrap(); // tao adds a gtk::Box by default
let fixed = gtk::Fixed::new();
fixed.show_all();
vbox.pack_start(&fixed, true, true, 0);
builder.build_gtk(&fixed).unwrap()
};
```
### 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.
```rust
#[derive(Default)]
struct App {
webview_window: Option<(Window, WebView)>,
}
impl ApplicationHandler for App {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
let window = event_loop.create_window(Window::default_attributes()).unwrap();
let webview = WebViewBuilder::new()
.with_url("https://tauri.app")
.build(&window)
.unwrap();
self.webview_window = Some((window, webview));
}
fn window_event(&mut self, _event_loop: &ActiveEventLoop, _window_id: WindowId, event: WindowEvent) {}
// Advance GTK event loop