fix: crisp HiDPI text via 1:1 blit, and Servo physical-resolution rendering

Author: franzos

CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.1.10] - 2026-05-26
+
+### Fixed
+- HiDPI text sharpness: webview content now blits 1:1 with the surface (nearest-neighbor sampling + rounded physical sizes) instead of being bilinear-resampled
+- Servo HiDPI: content was rendered at 2× size and upscaled (double-applied the display scale); Servo now paints a physical-resolution buffer matching its hidpi factor
+- Stale/inaccurate code comments around engine render-path routing and texture color space
+
 ## [0.1.9] - 2026-05-25
 
 ### Fixed

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "iced_webview_v2"
-version = "0.1.9"
+version = "0.1.10"
 edition = "2021"
 rust-version = "1.90.0"
 description = "An easily embedded webview library for iced"

Cargo.toml

@@ -146,8 +146,8 @@ fn create_document(
     scale: f32,
     color_scheme: ColorScheme,
 ) -> HtmlDocument {
-    let phys_w = (size.width as f32 * scale) as u32;
-    let phys_h = (size.height as f32 * scale) as u32;
+    let phys_w = (size.width as f32 * scale).round() as u32;
+    let phys_h = (size.height as f32 * scale).round() as u32;
 
     let config = DocumentConfig {
         base_url: if base_url.is_empty() {
@@ -218,8 +218,8 @@ fn render_view(view: &mut BlitzView, gpu: &mut GpuRasterizer) {
     };
 
     let scale = view.scale as f64;
-    let render_w = (w as f64 * scale) as u32;
-    let render_h = (h as f64 * scale) as u32;
+    let render_w = (w as f64 * scale).round() as u32;
+    let render_h = (h as f64 * scale).round() as u32;
 
     if render_w == 0 || render_h == 0 {
         view.last_frame = ImageInfo::blank(w, h);
@@ -398,8 +398,8 @@ impl Engine for Blitz {
             view.size = size;
             if let Some(ref mut doc) = view.document {
                 let scale = view.scale;
-                let phys_w = (size.width as f32 * scale) as u32;
-                let phys_h = (size.height as f32 * scale) as u32;
+                let phys_w = (size.width as f32 * scale).round() as u32;
+                let phys_h = (size.height as f32 * scale).round() as u32;
                 let mut vp = doc.viewport_mut();
                 vp.window_size = (phys_w, phys_h);
                 drop(vp);
@@ -417,8 +417,8 @@ impl Engine for Blitz {
         for view in self.views.values_mut() {
             view.scale = scale;
             if let Some(ref mut doc) = view.document {
-                let phys_w = (view.size.width as f32 * scale) as u32;
-                let phys_h = (view.size.height as f32 * scale) as u32;
+                let phys_w = (view.size.width as f32 * scale).round() as u32;
+                let phys_h = (view.size.height as f32 * scale).round() as u32;
                 let mut vp = doc.viewport_mut();
                 vp.window_size = (phys_w, phys_h);
                 vp.set_hidpi_scale(scale);

src/engines/blitz.rs

@@ -198,10 +198,20 @@ fn cursor_to_interaction(cursor: Cursor) -> Interaction {
     }
 }
 
+/// Logical (device-independent) size → physical device pixels. Servo lays out
+/// CSS at `device_size / hidpi`, so we feed it a physical-sized buffer and a
+/// matching hidpi factor — otherwise content is scaled twice on HiDPI displays.
+fn physical_size(size: Size<u32>, scale: f32) -> PhysicalSize<u32> {
+    PhysicalSize::new(
+        (size.width as f32 * scale).round().max(1.0) as u32,
+        (size.height as f32 * scale).round().max(1.0) as u32,
+    )
+}
+
 /// Paint a webview and capture the pixel buffer into `ImageInfo`.
-fn capture_frame(view: &mut ServoView, rendering_context: &SoftwareRenderingContext) {
-    let w = view.size.width;
-    let h = view.size.height;
+fn capture_frame(view: &mut ServoView, rendering_context: &SoftwareRenderingContext, scale: f32) {
+    let phys = physical_size(view.size, scale);
+    let (w, h) = (phys.width, phys.height);
     if w == 0 || h == 0 {
         return;
     }
@@ -246,20 +256,22 @@ impl Engine for Servo {
 
     fn render(&mut self, _size: Size<u32>) {
         let rc = Rc::clone(&self.rendering_context);
+        let scale = self.scale_factor;
         for view in self.views.values_mut() {
             if view.needs_render {
-                capture_frame(view, &rc);
+                capture_frame(view, &rc, scale);
             }
         }
     }
 
     fn request_render(&mut self, id: ViewId, _size: Size<u32>) {
         let rc = Rc::clone(&self.rendering_context);
+        let scale = self.scale_factor;
         let Some(view) = self.views.get_mut(id) else {
             return;
         };
         if view.needs_render {
-            capture_frame(view, &rc);
+            capture_frame(view, &rc, scale);
         }
     }
 
@@ -302,18 +314,22 @@ impl Engine for Servo {
         let webview = builder.build();
         webview.focus();
         webview.show();
-        webview.resize(PhysicalSize::new(w, h));
+        webview.set_hidpi_scale_factor(
+            euclid::Scale::<f32, DeviceIndependentPixel, DevicePixel>::new(self.scale_factor),
+        );
+        let phys = physical_size(size, self.scale_factor);
+        webview.resize(phys);
 
         let view = ServoView {
             webview,
             delegate_state,
             url: url_str,
             title: String::new(),
             cursor: Interaction::Idle,
-            last_frame: ImageInfo::blank(w, h),
+            last_frame: ImageInfo::blank(phys.width, phys.height),
             needs_render: true,
             size,
-            last_cursor: DevicePoint::new(w as f32 / 2.0, h as f32 / 2.0),
+            last_cursor: DevicePoint::new(phys.width as f32 / 2.0, phys.height as f32 / 2.0),
         };
         self.views.insert(view)
     }
@@ -343,7 +359,7 @@ impl Engine for Servo {
     }
 
     fn resize(&mut self, size: Size<u32>) {
-        let phys = PhysicalSize::new(size.width.max(1), size.height.max(1));
+        let phys = physical_size(size, self.scale_factor);
         for view in self.views.values_mut() {
             view.size = size;
             view.webview.resize(phys);
@@ -362,6 +378,7 @@ impl Engine for Servo {
                 DeviceIndependentPixel,
                 DevicePixel,
             >::new(scale));
+            view.webview.resize(physical_size(view.size, scale));
             view.needs_render = true;
         }
     }
@@ -376,7 +393,8 @@ impl Engine for Servo {
     }
 
     fn handle_mouse_event(&mut self, id: ViewId, point: Point, event: mouse::Event) {
-        let device_point = DevicePoint::new(point.x, point.y);
+        let device_point =
+            DevicePoint::new(point.x * self.scale_factor, point.y * self.scale_factor);
         let Some(view) = self.views.get_mut(id) else {
             return;
         };
@@ -419,12 +437,17 @@ impl Engine for Servo {
     }
 
     fn scroll(&mut self, id: ViewId, delta: mouse::ScrollDelta) {
+        let scale = self.scale_factor;
         let Some(view) = self.views.get_mut(id) else {
             return;
         };
         let (dx, dy, mode) = match delta {
             mouse::ScrollDelta::Lines { x, y } => (x as f64, y as f64, WheelMode::DeltaLine),
-            mouse::ScrollDelta::Pixels { x, y } => (x as f64, y as f64, WheelMode::DeltaPixel),
+            mouse::ScrollDelta::Pixels { x, y } => (
+                (x * scale) as f64,
+                (y * scale) as f64,
+                WheelMode::DeltaPixel,
+            ),
         };
         let cursor_point = view.last_cursor;
         view.webview

src/engines/servo.rs

@@ -567,7 +567,7 @@ impl<'a> shader::Program<Action> for AdvancedShaderProgram<'a> {
         bounds: Rectangle,
         cursor: mouse::Cursor,
     ) -> Option<shader::Action<Action>> {
-        let size = Size::new(bounds.width as u32, bounds.height as u32);
+        let size = Size::new(bounds.width.round() as u32, bounds.height.round() as u32);
         if state.bounds != size {
             state.bounds = size;
             return Some(shader::Action::publish(Action::Resize(size)));
@@ -712,14 +712,18 @@ where
                     height: self.content_height,
                 };
                 renderer.draw_image(
-                    core_image::Image::new(self.handle.clone()).snap(true),
+                    core_image::Image::new(self.handle.clone())
+                        .snap(true)
+                        .filter_method(core_image::FilterMethod::Nearest),
                     image_bounds,
                     *viewport,
                 );
             });
         } else {
             renderer.draw_image(
-                core_image::Image::new(self.handle.clone()).snap(true),
+                core_image::Image::new(self.handle.clone())
+                    .snap(true)
+                    .filter_method(core_image::FilterMethod::Nearest),
                 bounds,
                 *viewport,
             );
@@ -760,7 +764,10 @@ where
         shell: &mut Shell<'_, Action>,
         _viewport: &Rectangle,
     ) {
-        let size = Size::new(layout.bounds().width as u32, layout.bounds().height as u32);
+        let size = Size::new(
+            layout.bounds().width.round() as u32,
+            layout.bounds().height.round() as u32,
+        );
         if self.bounds != size {
             shell.publish(Action::Resize(size));
         }

src/webview/advanced.rs

@@ -534,8 +534,9 @@ impl<Engine: engines::Engine + Default, Message: Send + Clone + 'static> WebView
         let content_height = self.engine.get_content_height(id);
 
         if content_height > 0.0 {
-            // Engines that render a full-document buffer (blitz, litehtml):
-            // use the image Handle widget with y-offset scrolling.
+            // litehtml renders a full-document buffer: draw it with the image
+            // Handle widget and scroll by y-offset. (blitz/servo report height 0
+            // and take the shader path below.)
             WebViewWidget::new(
                 self.engine.get_view(id),
                 self.engine.get_cursor(id),
@@ -546,8 +547,8 @@ impl<Engine: engines::Engine + Default, Message: Send + Clone + 'static> WebView
             .into()
         } else {
             // Engines that manage their own scrolling and produce a viewport-
-            // sized frame each tick (servo): use the shader widget for direct
-            // GPU texture updates, avoiding Handle cache churn.
+            // sized frame each tick (servo, blitz, cef): use the shader widget
+            // for direct GPU texture updates, avoiding Handle cache churn.
             #[cfg(any(feature = "servo", feature = "cef", feature = "blitz"))]
             {
                 use crate::webview::shader_widget::WebViewShaderProgram;
@@ -674,14 +675,18 @@ where
                     height: self.content_height,
                 };
                 renderer.draw_image(
-                    core_image::Image::new(self.handle.clone()).snap(true),
+                    core_image::Image::new(self.handle.clone())
+                        .snap(true)
+                        .filter_method(core_image::FilterMethod::Nearest),
                     image_bounds,
                     *viewport,
                 );
             });
         } else {
             renderer.draw_image(
-                core_image::Image::new(self.handle.clone()).snap(true),
+                core_image::Image::new(self.handle.clone())
+                    .snap(true)
+                    .filter_method(core_image::FilterMethod::Nearest),
                 bounds,
                 *viewport,
             );
@@ -724,7 +729,10 @@ where
         shell: &mut Shell<'_, Action>,
         _viewport: &Rectangle,
     ) {
-        let size = Size::new(layout.bounds().width as u32, layout.bounds().height as u32);
+        let size = Size::new(
+            layout.bounds().width.round() as u32,
+            layout.bounds().height.round() as u32,
+        );
         if self.bounds != size {
             self.bounds = size;
             shell.publish(Action::Resize(size));

src/webview/basic.rs

@@ -81,7 +81,10 @@ impl WebViewPipeline {
     }
 }
 
-// Match the texture's color space to the surface: an sRGB target re-encodes our linear output, a linear (web-colors) target needs the sRGB bytes passed through untouched.
+// Match the texture format to the surface's color space. The engine produces
+// sRGB-encoded bytes: an sRGB surface needs an sRGB texture (decoded on sample,
+// re-encoded on write); a non-sRGB (web-colors) surface needs a plain texture
+// so the bytes pass through untouched.
 fn pick_texture_format(surface: wgpu::TextureFormat) -> wgpu::TextureFormat {
     if surface.is_srgb() {
         wgpu::TextureFormat::Rgba8UnormSrgb
@@ -173,10 +176,12 @@ impl shader::Pipeline for WebViewPipeline {
         let texture_format = pick_texture_format(format);
         let (texture, texture_view) = create_texture(device, 1, 1, texture_format);
 
+        // Buffer is rasterized at physical resolution, so it maps ~1:1 to the
+        // surface — nearest-neighbor keeps text crisp instead of resampling.
         let sampler = device.create_sampler(&wgpu::SamplerDescriptor {
             label: Some("webview_sampler"),
-            mag_filter: wgpu::FilterMode::Linear,
-            min_filter: wgpu::FilterMode::Linear,
+            mag_filter: wgpu::FilterMode::Nearest,
+            min_filter: wgpu::FilterMode::Nearest,
             ..Default::default()
         });
 
@@ -283,7 +288,7 @@ impl<'a> shader::Program<Action> for WebViewShaderProgram<'a> {
         bounds: Rectangle,
         cursor: mouse::Cursor,
     ) -> Option<shader::Action<Action>> {
-        let size = Size::new(bounds.width as u32, bounds.height as u32);
+        let size = Size::new(bounds.width.round() as u32, bounds.height.round() as u32);
         if state.bounds != size {
             state.bounds = size;
             return Some(shader::Action::publish(Action::Resize(size)));