feat: event-driven servo wake subscription

Author: franzos

CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.1.7] - 2026-04-21
+
+### Added
+- Servo engine: event-driven wake subscription via `webview.subscription()` — replaces hardcoded `time::every(...)` polling
+- `ServoWaker` signals the embedder only when Servo has work, with a 500ms fallback tick as a safety net
+- Examples updated to use the new Servo subscription when the `servo` feature is enabled
+
+### Changed
+- `servo` feature now depends on `tokio`; `tokio` dependency gains the `sync` feature for `Notify`
+
 ## [0.1.6] - 2026-04-03
 
 ### Added

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "iced_webview_v2"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 rust-version = "1.90.0"
 description = "An easily embedded webview library for iced"
@@ -40,7 +40,7 @@ blitz = [
     "dep:tokio",
 ]
 litehtml = ["dep:litehtml", "dep:reqwest"]
-servo = ["dep:servo", "dep:urlencoding", "dep:rustls", "dep:euclid", "dep:keyboard-types-servo", "dep:dpi"]
+servo = ["dep:servo", "dep:urlencoding", "dep:rustls", "dep:euclid", "dep:keyboard-types-servo", "dep:dpi", "dep:tokio"]
 cef = ["dep:cef", "dep:urlencoding"]
 docs_only = []
 
@@ -63,7 +63,7 @@ peniko = { version = "0.6", optional = true }
 cursor-icon = { version = "1", optional = true }
 keyboard-types = { version = "0.7", optional = true }
 smol_str = { version = "0.3", optional = true }
-tokio = { version = "1", features = ["rt"], optional = true }
+tokio = { version = "1", features = ["rt", "sync"], optional = true }
 
 # Servo engine deps
 servo = { version = "0.1", optional = true }

Cargo.toml

@@ -1,9 +1,12 @@
 use iced::{
-    time,
     widget::{column, text},
     Element, Subscription, Task,
 };
 use iced_webview::{Action, PageType, WebView};
+
+#[cfg(not(feature = "servo"))]
+use iced::time;
+#[cfg(not(feature = "servo"))]
 use std::time::Duration;
 
 #[cfg(feature = "cef")]
@@ -154,8 +157,15 @@ impl App {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        time::every(Duration::from_millis(16))
-            .map(|_| Action::Update)
-            .map(Message::WebView)
+        #[cfg(feature = "servo")]
+        {
+            self.webview.subscription().map(Message::WebView)
+        }
+        #[cfg(not(feature = "servo"))]
+        {
+            time::every(Duration::from_millis(16))
+                .map(|_| Action::Update)
+                .map(Message::WebView)
+        }
     }
 }

examples/email.rs

@@ -1,9 +1,12 @@
 use iced::{
-    time,
     widget::{button, column, container, row, text},
     Element, Length, Subscription, Task,
 };
 use iced_webview::{Action, PageType, WebView};
+
+#[cfg(not(feature = "servo"))]
+use iced::time;
+#[cfg(not(feature = "servo"))]
 use std::time::Duration;
 
 #[cfg(feature = "cef")]
@@ -137,8 +140,15 @@ impl App {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        time::every(Duration::from_millis(10))
-            .map(|_| Action::Update)
-            .map(Message::WebView)
+        #[cfg(feature = "servo")]
+        {
+            self.webview.subscription().map(Message::WebView)
+        }
+        #[cfg(not(feature = "servo"))]
+        {
+            time::every(Duration::from_millis(10))
+                .map(|_| Action::Update)
+                .map(Message::WebView)
+        }
     }
 }

examples/embedded_webview.rs

@@ -1,5 +1,9 @@
-use iced::{time, Element, Subscription, Task};
+use iced::{Element, Subscription, Task};
 use iced_webview::{Action, PageType, WebView};
+
+#[cfg(not(feature = "servo"))]
+use iced::time;
+#[cfg(not(feature = "servo"))]
 use std::time::Duration;
 
 #[cfg(feature = "cef")]
@@ -76,8 +80,15 @@ impl App {
     }
 
     fn subscription(&self) -> Subscription<Message> {
-        time::every(Duration::from_millis(10))
-            .map(|_| Action::Update)
-            .map(Message::WebView)
+        #[cfg(feature = "servo")]
+        {
+            self.webview.subscription().map(Message::WebView)
+        }
+        #[cfg(not(feature = "servo"))]
+        {
+            time::every(Duration::from_millis(10))
+                .map(|_| Action::Update)
+                .map(Message::WebView)
+        }
     }
 }

examples/webview.rs

@@ -1,9 +1,13 @@
 use std::cell::RefCell;
+use std::hash::{Hash, Hasher};
 use std::rc::Rc;
+use std::sync::Arc;
+use std::time::Duration;
 
 use iced::keyboard;
 use iced::mouse::{self, Interaction};
 use iced::{Point, Size};
+use tokio::sync::Notify;
 
 use super::{Engine, PageType, PixelFormat, ViewId, ViewManager};
 use crate::ImageInfo;
@@ -20,12 +24,35 @@ use servo::{
 };
 use url::Url;
 
-/// No-op waker — the iced subscription tick already drives `spin_event_loop`.
-struct NoOpWaker;
+/// Event-driven waker that Servo calls (from any thread) whenever it wants the
+/// embedder to spin its event loop. The `Notify` coalesces multiple wake signals
+/// into a single pending notification, so a burst of calls produces at most one
+/// wake-up on the consumer side.
+#[derive(Clone)]
+struct ServoWaker {
+    notify: Arc<Notify>,
+}
 
-impl servo::EventLoopWaker for NoOpWaker {
+impl servo::EventLoopWaker for ServoWaker {
     fn clone_box(&self) -> Box<dyn servo::EventLoopWaker> {
-        Box::new(NoOpWaker)
+        Box::new(self.clone())
+    }
+
+    fn wake(&self) {
+        self.notify.notify_one();
+    }
+}
+
+/// Hashable handle used to give the Servo wake subscription a stable identity
+/// in the iced runtime. Hashing the `Arc`'s pointer address is enough —
+/// each `Servo` instance has its own `Notify`, so two different engines get
+/// two distinct subscriptions.
+#[derive(Clone)]
+struct WakeSubId(Arc<Notify>);
+
+impl Hash for WakeSubId {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        (Arc::as_ptr(&self.0) as usize).hash(state);
     }
 }
 
@@ -92,6 +119,10 @@ pub struct Servo {
     rendering_context: Rc<SoftwareRenderingContext>,
     views: ViewManager<ServoView>,
     scale_factor: f32,
+    /// Shared with `ServoWaker` — Servo signals this whenever it wants the
+    /// embedder to call `spin_event_loop`. The iced subscription exposed by
+    /// [`Servo::subscription`] awaits the same handle.
+    notify: Arc<Notify>,
 }
 
 impl Default for Servo {
@@ -101,19 +132,52 @@ impl Default for Servo {
             SoftwareRenderingContext::new(size).expect("failed to create SoftwareRenderingContext");
         let rendering_context = Rc::new(rendering_context);
 
+        let notify = Arc::new(Notify::new());
+        let waker = ServoWaker {
+            notify: Arc::clone(&notify),
+        };
+
         let instance = ServoBuilder::default()
-            .event_loop_waker(Box::new(NoOpWaker))
+            .event_loop_waker(Box::new(waker))
             .build();
 
         Self {
             instance,
             rendering_context,
             views: ViewManager::default(),
             scale_factor: 1.0,
+            notify,
         }
     }
 }
 
+impl Servo {
+    /// An iced [`Subscription`] that yields [`Action::Update`] whenever Servo
+    /// signals it has work to do, plus a 500ms safety tick so the event loop
+    /// still runs if a wake is somehow missed. This replaces the hardcoded
+    /// `time::every(10ms)` pattern used for other engines.
+    ///
+    /// [`Subscription`]: iced::Subscription
+    /// [`Action::Update`]: crate::Action::Update
+    pub fn subscription(&self) -> iced::Subscription<crate::Action> {
+        use iced::futures::SinkExt;
+
+        let id = WakeSubId(Arc::clone(&self.notify));
+
+        let wake_stream = iced::Subscription::run_with(id, |id| {
+            let notify = Arc::clone(&id.0);
+            iced::stream::channel(1, async move |mut output| loop {
+                notify.notified().await;
+                let _ = output.send(crate::Action::Update).await;
+            })
+        });
+
+        let fallback = iced::time::every(Duration::from_millis(500)).map(|_| crate::Action::Update);
+
+        iced::Subscription::batch([wake_stream, fallback])
+    }
+}
+
 fn cursor_to_interaction(cursor: Cursor) -> Interaction {
     match cursor {
         Cursor::Pointer => Interaction::Pointer,

src/engines/servo.rs

@@ -588,6 +588,17 @@ impl<Engine: engines::Engine + Default, Message: Send + Clone + 'static> WebView
     }
 }
 
+#[cfg(feature = "servo")]
+impl<Message: Send + Clone + 'static> WebView<crate::engines::servo::Servo, Message> {
+    /// Event-driven subscription for the Servo engine — yields
+    /// [`Action::Update`] whenever Servo wakes the embedder, with a 500ms
+    /// fallback tick. Use this in place of a hardcoded `time::every(...)`
+    /// timer when running with the `servo` feature.
+    pub fn subscription(&self) -> iced::Subscription<Action> {
+        self.engine.subscription()
+    }
+}
+
 struct WebViewWidget<'a> {
     handle: core_image::Handle,
     cursor: Interaction,