working to make it more stabel

- Added Cargo.toml with dependencies for egui, wgpu, and other libraries.
- Implemented main application logic in src/app.rs, including window management, rendering, and tab handling.
- Created a new module src/servo_host.rs to manage interactions with the Servo engine and webview.
- Established event handling for user inputs, including keyboard and mouse events.
- Integrated a basic UI layout with a tab strip, toolbar, and status bar.
- Implemented functionality for navigating URLs and managing multiple tabs.

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,31 @@
+[package]
+name = "browser"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+egui = "0.36.1"
+egui-wgpu = "0.36.1"
+egui-winit = "0.36.1"
+env_logger = "0.11.11"
+euclid = "0.22"
+image = "0.25"
+keyboard-types = "0.8"
+log = "0.4.33"
+objc2 = "0.6"
+objc2-quartz-core = "0.3"
+pollster = "0.4"
+rustls = "0.23"
+servo = "0.5.0"
+url = "2"
+wgpu = "30.0.0"
+winit = "0.30.13"
+
+[profile.dev.package."*"]
+# Optimize dependencies (Servo, WebRender, wgpu…) even in dev builds —
+# unoptimized engines are unusably slow, while keeping our crate debuggable.
+opt-level = 2
+
+[profile.release]
+lto = "thin"
+codegen-units = 1

README.md

@@ -1,2 +1,77 @@
 # browser
-idk
+
+A minimal Firefox-style web browser built on [Servo](https://servo.org), the Rust web engine — **the newest actively maintained browser built on Servo**, written against the [`servo` crate](https://crates.io/crates/servo) embedding API (v0.1+, released April 2026).
+
+> **Context:** [Verso](https://github.com/versotile-org/verso), the pioneering third-party Servo browser, was archived in October 2025 and is no longer maintained. Servo's own servoshell remains a demo mini-browser for testing the engine. This project picks up the embedder-side baton on the new public `servo` crates.io API — no engine fork required.
+
+## What works
+
+- Tab strip with create/close/switch
+- Back / forward / reload navigation with real history state
+- URL bar with address parsing and DuckDuckGo search fallback (`localhost` handled too)
+- Pages render via Servo into offscreen surfaces and composite under the native chrome
+- Mouse, scroll wheel, and keyboard input forwarded to the page
+- Live page titles, loading spinners, and hover status bar
+- `window.open()` / target=_blank opens a new tab
+
+## Architecture
+
+```
+┌──────────────────────────────────────────┐
+│ Chrome UI: egui 0.36 + wgpu              │  tabs · toolbar · status bar
+├──────────────────────────────────────────┤
+│ Frame bridge                             │  WebView::paint() → read_to_image()
+├──────────────────────────────────────────┤
+│ Engine: servo 0.5 crate                  │  Stylo · SpiderMonkey · WebRender
+│   one WebView per tab, each with its own │
+│   OffscreenRenderingContext              │
+└──────────────────────────────────────────┘
+        windowing: winit · rendering: wgpu (Metal/Vulkan/DX12)
+```
+
+The embedder owns everything above the engine: windowing, chrome, input routing,
+and history UI. Servo owns layout, JS, networking, and painting. The two talk through
+`WebView::notify_input_event` (down) and a `WebViewDelegate` message queue (up).
+
+## Building
+
+Requires a stable Rust toolchain (1.85+ recommended):
+
+```sh
+cargo build --release
+cargo run --release
+```
+
+First build takes a while — the servo crate compiles SpiderMonkey (C++) and the full
+WebRender pipeline. Incremental rebuilds after that are fast.
+
+Tested on macOS (Apple Silicon). Windows and Linux should work in principle since all
+dependencies are cross-platform, but they haven't been exercised yet.
+
+## Known limitations
+
+This is an early-days project on top of an engine that is itself pre-1.0:
+
+- No DRM video (Widevine), and some sites will simply not render correctly yet —
+  that's Servo's web-compat surface area, not something the embedder can fix
+- Frames are composited through CPU readback, so heavy pages cost more than a
+  zero-copy GPU path would (fine for basic browsing)
+- No bookmarks/history persistence, downloads, devtools, or preferences UI yet
+
+## Roadmap
+
+- [ ] Zero-copy frame path (share GL textures instead of readback)
+- [ ] Bookmarks and browsing history
+- [ ] Page context menus
+- [ ] Dark mode following system theme
+- [ ] Linux CI builds
+
+## Credits
+
+Built on the shoulders of the [Servo project](https://servo.org) (Linux Foundation Europe),
+with the chrome rendered by [egui](https://github.com/emilk/egui). Design cues from Firefox.
+See also [Verso](https://github.com/versotile-org/verso) (archived) — the pioneering Servo embedder whose contributions live on upstream.
+
+## License
+
+See [LICENSE](LICENSE).

src/app.rs

@@ -0,0 +1,963 @@
+use std::cell::Cell;
+use std::rc::Rc;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+
+use egui_wgpu::{Renderer, RendererOptions, ScreenDescriptor};
+use egui_winit::State as EguiWinitState;
+use keyboard_types::Modifiers;
+use objc2::msg_send;
+use objc2::runtime::AnyObject;
+use objc2_quartz_core::CAMetalLayer;
+use servo::RenderingContext;
+use url::Url;
+use winit::application::ApplicationHandler;
+use winit::dpi::{LogicalPosition, LogicalSize, PhysicalPosition, PhysicalSize};
+use winit::event::{ElementState, WindowEvent};
+use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoopProxy};
+use winit::raw_window_handle::{HasDisplayHandle, HasWindowHandle, RawWindowHandle};
+use winit::window::{Window, WindowId};
+
+use crate::servo_host::{
+    self, make_keyboard_input, winit_button_action_to_servo, winit_button_to_servo, wheel_input,
+    Engine, EngineMsg, EguiWaker, Tab,
+};
+use crate::UserEvent;
+
+const START_PAGE: &str = "https://servo.org/";
+const CHROME_BG: egui::Color32 = egui::Color32::from_rgb(240, 240, 244);
+const CHROME_BG_DARKER: egui::Color32 = egui::Color32::from_rgb(223, 223, 230);
+const TAB_ACTIVE_BG: egui::Color32 = egui::Color32::WHITE;
+const ACCENT: egui::Color32 = egui::Color32::from_rgb(0, 97, 224);
+
+/// Minimum time between expensive GPU->CPU page readbacks (~one vsync).
+const MIN_PAINT_INTERVAL: Duration = Duration::from_millis(15);
+
+pub struct BrowserApp {
+    proxy: EventLoopProxy<UserEvent>,
+    window: Option<Arc<Window>>,
+    gpu: Option<Gpu>,
+    // NOTE: `tabs` must be dropped BEFORE `engine` — closing a WebView sends a
+    // message to Servo, which must still be alive when that happens.
+    tabs: Vec<Tab>,
+    engine: Option<Rc<Engine>>,
+    active: usize,
+    url_edit: String,
+    url_bar_focused: bool,
+    content_focused: bool,
+    content_rect: egui::Rect,
+    last_cursor_pos: PhysicalPosition<f64>,
+    modifiers: Modifiers,
+    scale_factor: f64,
+    pending_close: Option<usize>,
+}
+
+struct Gpu {
+    surface: wgpu::Surface<'static>,
+    device: wgpu::Device,
+    queue: wgpu::Queue,
+    config: wgpu::SurfaceConfiguration,
+    egui_ctx: egui::Context,
+    egui_winit: EguiWinitState,
+    renderer: Renderer,
+}
+
+impl BrowserApp {
+    pub fn new(proxy: EventLoopProxy<UserEvent>) -> BrowserApp {
+        BrowserApp {
+            proxy,
+            window: None,
+            gpu: None,
+            tabs: Vec::new(),
+            engine: None,
+            active: 0,
+            url_edit: START_PAGE.to_owned(),
+            url_bar_focused: false,
+            content_focused: false,
+            content_rect: egui::Rect::NOTHING,
+            last_cursor_pos: PhysicalPosition::new(0.0, 0.0),
+            modifiers: Modifiers::empty(),
+            scale_factor: 1.0,
+            pending_close: None,
+        }
+    }
+
+    fn init(&mut self, event_loop: &ActiveEventLoop) -> Result<(), Box<dyn std::error::Error>> {
+        let attrs = Window::default_attributes()
+            .with_title("Fox")
+            .with_inner_size(LogicalSize::new(1360.0, 900.0))
+            .with_position(LogicalPosition::new(40.0, 40.0));
+        let window = Arc::new(event_loop.create_window(attrs)?);
+        self.scale_factor = window.scale_factor();
+        let size = window.inner_size();
+
+        // The Servo (surfman) rendering context REPLACES the view's root CALayer
+        // with its own plain layer. It must be created and detached again before
+        // wgpu grabs the view's layer, otherwise wgpu presents into an orphaned
+        // CAMetalLayer and nothing ever appears on screen.
+        let display_handle = event_loop
+            .display_handle()
+            .map_err(|e| format!("no display handle: {e:?}"))?;
+        let window_handle = window
+            .window_handle()
+            .map_err(|e| format!("no window handle: {e:?}"))?;
+        let window_context = Rc::new(servo::WindowRenderingContext::new(
+            display_handle,
+            window_handle,
+            size,
+        )
+        .map_err(|e| format!("failed to create Servo rendering context: {e:?}"))?);
+        window_context.make_current().ok();
+        window_context.take_window().ok();
+
+        // take_window() removes surfman's content sublayer but leaves its empty
+        // root superlayer installed on the view; swap in a fresh CAMetalLayer.
+        {
+            let ns_view = match window.window_handle()?.as_raw() {
+                RawWindowHandle::AppKit(h) => h.ns_view.as_ptr() as *mut AnyObject,
+                other => {
+                    return Err(format!("unsupported window handle: {other:?}").into());
+                }
+            };
+            let metal_layer = CAMetalLayer::new();
+            unsafe {
+                let _: () = msg_send![ns_view, setLayer: &*metal_layer];
+                let _: () = msg_send![ns_view, setWantsLayer: true];
+            }
+        }
+
+        let instance = wgpu::Instance::new(wgpu::InstanceDescriptor::new_without_display_handle());
+        let surface = instance.create_surface(window.clone())?;
+        let adapter = pollster::block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+            power_preference: wgpu::PowerPreference::HighPerformance,
+            compatible_surface: Some(&surface),
+            force_fallback_adapter: false,
+            ..Default::default()
+        }))?;
+
+        let caps = surface.get_capabilities(&adapter);
+        let format = caps.formats[0];
+        let config = wgpu::SurfaceConfiguration {
+            usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
+            format,
+            width: size.width.max(1),
+            height: size.height.max(1),
+            present_mode: wgpu::PresentMode::Fifo,
+            alpha_mode: caps.alpha_modes[0],
+            view_formats: vec![],
+            desired_maximum_frame_latency: 2,
+            color_space: wgpu::SurfaceColorSpace::Auto,
+        };
+
+        let (device, queue) = pollster::block_on(adapter.request_device(&wgpu::DeviceDescriptor {
+            label: Some("fox-device"),
+            required_features: wgpu::Features::empty(),
+            required_limits: wgpu::Limits::default(),
+            memory_hints: wgpu::MemoryHints::default(),
+            ..Default::default()
+        }))?;
+        surface.configure(&device, &config);
+
+        let egui_ctx = egui::Context::default();
+        {
+            let proxy = self.proxy.clone();
+            egui_ctx.set_request_repaint_callback(move |info| {
+                let _ = proxy.send_event(UserEvent::RepaintAfter(info.delay));
+            });
+        }
+        let mut egui_winit = EguiWinitState::new(
+            egui_ctx.clone(),
+            egui::ViewportId::ROOT,
+            &display_handle,
+            Some(self.scale_factor as f32),
+            None,
+            None,
+        );
+        egui_winit.set_max_texture_side(device.limits().max_texture_dimension_2d as usize);
+        let mut renderer = Renderer::new(&device, format, RendererOptions::default());
+        // Warm up the context so `max_texture_side` from RawInput is applied
+        // before the first page-texture upload (otherwise egui validates
+        // against its built-in default of 2048 and panics on large textures).
+        // The pass also emits the font atlas delta, which must be uploaded.
+        let mut warmup = egui_ctx.run_ui(
+            egui::RawInput {
+                max_texture_side: Some(device.limits().max_texture_dimension_2d as usize),
+                ..egui::RawInput::default()
+            },
+            |_| {},
+        );
+        for (id, deltas) in &warmup.textures_delta.set {
+            for delta in deltas {
+                renderer.update_texture(&device, &queue, *id, delta);
+            }
+        }
+        for id in &warmup.textures_delta.free {
+            renderer.free_texture(id);
+        }
+        warmup.textures_delta.clear();
+
+        self.apply_style(&egui_ctx);
+
+        let waker = EguiWaker(egui_ctx.clone());
+        let engine = Rc::new(Engine::new(waker, window_context));
+
+        let start_url = Url::parse(START_PAGE)?;
+        let tab = engine.create_tab(start_url, self.scale_factor as f32);
+        self.tabs.push(tab);
+        self.active = 0;
+        self.engine = Some(engine);
+
+        self.gpu = Some(Gpu {
+            surface,
+            device,
+            queue,
+            config,
+            egui_ctx,
+            egui_winit,
+            renderer,
+        });
+        self.window = Some(window.clone());
+
+        window.request_redraw();
+        Ok(())
+    }
+
+    fn apply_style(&self, ctx: &egui::Context) {
+        ctx.set_theme(egui::ThemePreference::Light);
+        let mut visuals = egui::Visuals::light();
+        visuals.panel_fill = CHROME_BG;
+        visuals.widgets.noninteractive.bg_fill = CHROME_BG;
+        visuals.selection.stroke.color = ACCENT;
+        ctx.set_visuals_of(egui::Theme::Light, visuals);
+    }
+
+    fn active_tab(&self) -> Option<&Tab> {
+        self.tabs.get(self.active)
+    }
+
+    fn active_tab_mut(&mut self) -> Option<&mut Tab> {
+        self.tabs.get_mut(self.active)
+    }
+
+    fn tab_by_id_mut(&mut self, id: servo::WebViewId) -> Option<&mut Tab> {
+        self.tabs.iter_mut().find(|t| t.id == id)
+    }
+
+    fn active_id(&self) -> Option<servo::WebViewId> {
+        self.tabs.get(self.active).map(|t| t.id)
+    }
+
+    fn navigate_active(&mut self, input: &str) {
+        let Some(url) = parse_location(input.trim()) else {
+            return;
+        };
+        if let Some(tab) = self.active_tab_mut() {
+            tab.webview.load(url);
+            tab.dirty = true;
+        }
+    }
+
+    fn open_new_tab(&mut self) {
+        let Some(engine) = self.engine.clone() else {
+            return;
+        };
+        let url = Url::parse(START_PAGE).expect("valid start page");
+        let tab = engine.create_tab(url, self.scale_factor as f32);
+        self.tabs.push(tab);
+        self.active = self.tabs.len() - 1;
+        self.content_focused = false;
+        self.url_edit = START_PAGE.to_owned();
+    }
+
+    fn close_tab(&mut self, index: usize) {
+        if index >= self.tabs.len() {
+            return;
+        }
+        self.tabs.remove(index);
+        if self.tabs.is_empty() {
+            self.open_new_tab();
+            return;
+        }
+        if self.active >= self.tabs.len() {
+            self.active = self.tabs.len() - 1;
+        } else if index < self.active {
+            self.active -= 1;
+        }
+        self.content_focused = false;
+    }
+
+    fn drain_engine_messages(&mut self) {
+        let Some(engine) = self.engine.clone() else {
+            return;
+        };
+        let messages: Vec<EngineMsg> = engine.queue.borrow_mut().drain(..).collect();
+        for msg in messages {
+            match msg {
+                EngineMsg::UrlChanged(id, url) => {
+                    let is_active = Some(id) == self.active_id();
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.url_string.clone_from(&url);
+                        if is_active && !self.url_bar_focused {
+                            self.url_edit.clone_from(&url);
+                        }
+                    }
+                }
+                EngineMsg::TitleChanged(id, title) => {
+                    let is_active = Some(id) == self.active_id();
+                    let display = title.unwrap_or_else(|| {
+                        fallback_title(&self
+                            .tabs
+                            .iter()
+                            .find(|t| t.id == id)
+                            .map(|t| t.url_string.clone())
+                            .unwrap_or_default())
+                    });
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.title.clone_from(&display);
+                    }
+                    if is_active {
+                        if let Some(window) = self.window.as_ref() {
+                            window.set_title(&format!("{display} — Fox"));
+                        }
+                    }
+                }
+                EngineMsg::StatusText(id, status) => {
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.status_text = status;
+                    }
+                }
+                EngineMsg::LoadStatus(id, loading) => {
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.loading = loading;
+                    }
+                }
+                EngineMsg::NewFrame(id) => {
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.dirty = true;
+                    }
+                }
+                EngineMsg::Animating(id, animating) => {
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.animating = animating;
+                    }
+                }
+                EngineMsg::Crashed(id, reason) => {
+                    if let Some(tab) = self.tab_by_id_mut(id) {
+                        tab.title = format!("Crashed: {reason}");
+                        tab.loading = false;
+                    }
+                }
+                EngineMsg::Closed(id) => {
+                    if let Some(index) = self.tabs.iter().position(|t| t.id == id) {
+                        self.close_tab(index);
+                    }
+                }
+                EngineMsg::NewWebView(webview) => {
+                    let mut tab = Tab::adopt(webview);
+                    tab.dirty = true;
+                    self.tabs.push(tab);
+                    self.active = self.tabs.len() - 1;
+                    self.url_edit.clear();
+                }
+            }
+        }
+    }
+
+    fn sync_viewport_and_paint(&mut self) {
+        let ppp = self.scale_factor as f32;
+        let egui_ctx = self.gpu.as_ref().map(|g| g.egui_ctx.clone());
+        let content = self.content_rect;
+
+        let Some(tab) = self.active_tab_mut() else {
+            return;
+        };
+        if content.is_positive() {
+            let phys_w = (content.width() * ppp).round() as u32;
+            let phys_h = (content.height() * ppp).round() as u32;
+            let current = tab.webview.size();
+            let cur = (current.width.round() as u32, current.height.round() as u32);
+            if cur != (phys_w, phys_h) && phys_w > 0 && phys_h > 0 {
+                tab.webview.resize(PhysicalSize::new(phys_w, phys_h));
+                tab.dirty = true;
+            }
+        }
+
+        if !tab.dirty {
+            return;
+        }
+        // Throttle GPU->CPU readbacks: a full-surface read is expensive, so skip
+        // frames arriving sooner than one vsync after the previous read. Keep the
+        // dirty flag so the next redraw picks the newer frame up instead.
+        if tab.last_paint.elapsed() < MIN_PAINT_INTERVAL {
+            return;
+        }
+        tab.webview.paint();
+
+        let size = tab.webview.size();
+        let w = size.width.round() as i32;
+        let h = size.height.round() as i32;
+        if w <= 0 || h <= 0 {
+            return;
+        }
+        let rect = euclid::Box2D::from_origin_and_size(euclid::point2(0, 0), euclid::size2(w, h));
+        let rc = tab.webview.rendering_context();
+        if let Some(img) = rc.read_to_image(rect) {
+            tab.last_paint = Instant::now();
+            let dims = [img.width() as usize, img.height() as usize];
+            let pixels = img.into_raw();
+            // Skip the (expensive) texture re-upload when nothing changed.
+            let hash = {
+                use std::hash::{Hash, Hasher};
+                let mut hasher = std::collections::hash_map::DefaultHasher::new();
+                pixels.len().hash(&mut hasher);
+                for chunk in pixels.chunks(4096) {
+                    chunk.hash(&mut hasher);
+                }
+                hasher.finish()
+            };
+            if hash == tab.last_frame_hash && tab.texture.is_some() {
+                tab.dirty = false;
+                return;
+            }
+            tab.last_frame_hash = hash;
+            let image = egui::ColorImage::from_rgba_unmultiplied(dims, &pixels);
+            match (&tab.texture, &egui_ctx) {
+                (Some(texture), _) => {
+                    texture.clone().set(image, egui::TextureOptions::LINEAR);
+                }
+                (None, Some(ctx)) => {
+                    let name = format!("page-{:?}", tab.id);
+                    tab.texture = Some(ctx.load_texture(name, image, egui::TextureOptions::LINEAR));
+                }
+                (None, None) => {}
+            }
+        }
+        tab.dirty = false;
+    }
+
+    fn build_ui(&mut self, ui: &mut egui::Ui) {
+        egui::Panel::top("chrome").show(ui, |ui| {
+            ui.vertical(|ui| {
+                self.tab_strip(ui);
+                ui.separator();
+                self.toolbar(ui);
+            });
+        });
+
+        let hover_status = self
+            .active_tab()
+            .and_then(|t| t.status_text.clone())
+            .filter(|s| !s.is_empty());
+        if let Some(status) = hover_status {
+            egui::Panel::bottom("statusbar")
+                .frame(
+                    egui::Frame::new()
+                        .fill(CHROME_BG_DARKER)
+                        .inner_margin(egui::Margin::symmetric(8, 3)),
+                )
+                .show(ui, |ui| {
+                    ui.set_min_height(18.0);
+                    ui.label(
+                        egui::RichText::new(status)
+                            .small()
+                            .color(egui::Color32::from_gray(70)),
+                    );
+                });
+        }
+
+        egui::CentralPanel::default()
+            .frame(egui::Frame::new().fill(egui::Color32::WHITE))
+            .show(ui, |ui| {
+                let rect = ui.available_rect_before_wrap();
+                ui.allocate_rect(rect, egui::Sense::hover());
+                self.content_rect = rect;
+                let Some(texture) = self.active_tab().and_then(|t| t.texture.clone()) else {
+                    ui.centered_and_justified(|ui| {
+                        ui.label("Starting up the Servo engine…");
+                    });
+                    return;
+                };
+                ui.put(
+                    rect,
+                    egui::Image::new(&texture).fit_to_exact_size(rect.size()),
+                );
+            });
+
+        let busy = self
+            .tabs
+            .iter()
+            .any(|t| t.loading || t.animating || t.dirty);
+        if busy {
+            ui.ctx().request_repaint_after(Duration::from_millis(50));
+        }
+    }
+
+    fn tab_strip(&mut self, ui: &mut egui::Ui) {
+        ui.horizontal(|ui| {
+            ui.spacing_mut().item_spacing.x = 4.0;
+            ui.add_space(4.0);
+            for i in 0..self.tabs.len() {
+                self.single_tab(ui, i, i == self.active);
+            }
+            if ui
+                .add(
+                    egui::Button::new("+")
+                        .min_size(egui::vec2(26.0, 24.0))
+                        .corner_radius(5.0),
+                )
+                .on_hover_text("New tab")
+                .clicked()
+            {
+                self.open_new_tab();
+            }
+        });
+    }
+
+    fn single_tab(&mut self, ui: &mut egui::Ui, index: usize, is_active: bool) {
+        let Some(tab) = self.tabs.get(index) else {
+            return;
+        };
+        let title = truncate_title(&tab.title, 28);
+        let loading = tab.loading;
+        let bg = if is_active { TAB_ACTIVE_BG } else { CHROME_BG };
+
+        let activate = Cell::new(false);
+        let close = Cell::new(false);
+
+        egui::Frame::new()
+            .fill(bg)
+            .corner_radius(egui::CornerRadius {
+                nw: 7,
+                ne: 7,
+                sw: 0,
+                se: 0,
+            })
+            .inner_margin(egui::Margin::symmetric(8, 3))
+            .show(ui, |ui| {
+                let tab_response = ui
+                    .horizontal(|ui| {
+                        if loading {
+                            ui.add(egui::Spinner::new().size(12.0));
+                        }
+                        let label = egui::RichText::new(&title).size(13.0);
+                        if ui
+                            .add(egui::Button::new(label).fill(egui::Color32::TRANSPARENT))
+                            .clicked()
+                        {
+                            activate.set(true);
+                        }
+                        if ui.small_button(egui::RichText::new("×").size(11.0)).clicked() {
+                            close.set(true);
+                        }
+                    })
+                    .response;
+                if tab_response.clicked() {
+                    activate.set(true);
+                }
+            });
+
+        if close.get() {
+            self.pending_close = Some(index);
+            return;
+        }
+        if activate.get() && self.active != index {
+            self.active = index;
+            self.content_focused = false;
+            if !self.url_bar_focused {
+                if let Some(tab) = self.tabs.get(index) {
+                    self.url_edit.clone_from(&tab.url_string);
+                }
+            }
+            if let Some(tab) = self.tabs.get_mut(index) {
+                tab.dirty = true;
+            }
+        }
+    }
+
+    fn toolbar(&mut self, ui: &mut egui::Ui) {
+        let can_back = self.active_tab().map(|t| t.webview.can_go_back()) == Some(true);
+        let can_forward = self.active_tab().map(|t| t.webview.can_go_forward()) == Some(true);
+        let loading = self.active_tab().map(|t| t.loading) == Some(true);
+
+        ui.horizontal(|ui| {
+            ui.add_space(4.0);
+            ui.add_enabled_ui(can_back, |ui| {
+                if nav_button(ui, "←", "Go back").clicked() {
+                    if let Some(tab) = self.active_tab_mut() {
+                        tab.webview.go_back(1);
+                    }
+                }
+            });
+            ui.add_enabled_ui(can_forward, |ui| {
+                if nav_button(ui, "→", "Go forward").clicked() {
+                    if let Some(tab) = self.active_tab_mut() {
+                        tab.webview.go_forward(1);
+                    }
+                }
+            });
+            if nav_button(ui, if loading { "◌" } else { "↻" }, "Reload").clicked() {
+                if let Some(tab) = self.active_tab_mut() {
+                    tab.webview.reload();
+                }
+            }
+
+            let url_field = egui::TextEdit::singleline(&mut self.url_edit)
+                .hint_text("Search with DuckDuckGo or enter address")
+                .desired_width(ui.available_width() - 12.0)
+                .font(egui::TextStyle::Small);
+            let response = ui.add(url_field);
+            self.url_bar_focused = response.has_focus();
+            if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+                let text = self.url_edit.clone();
+                self.navigate_active(&text);
+                response.request_focus();
+            }
+            ui.add_space(4.0);
+        });
+    }
+
+    fn point_inside_content(&self, pos: PhysicalPosition<f64>) -> bool {
+        let ppp = self.scale_factor as f32;
+        let x = pos.x as f32 / ppp;
+        let y = pos.y as f32 / ppp;
+        self.content_rect.contains(egui::Pos2::new(x, y))
+    }
+
+    fn content_point(&self, pos: PhysicalPosition<f64>) -> servo::DevicePoint {
+        let ppp = self.scale_factor;
+        servo::DevicePoint::new(
+            (pos.x - self.content_rect.min.x as f64 * ppp) as f32,
+            (pos.y - self.content_rect.min.y as f64 * ppp) as f32,
+        )
+    }
+
+    fn forward_pointer_move(&mut self) {
+        let pos = self.last_cursor_pos;
+        if !self.point_inside_content(pos) {
+            return;
+        }
+        let origin_x = self.content_rect.min.x as f64 * self.scale_factor;
+        let origin_y = self.content_rect.min.y as f64 * self.scale_factor;
+        let point = servo::DevicePoint::new(
+            (pos.x - origin_x) as f32,
+            (pos.y - origin_y) as f32,
+        );
+        if let Some(tab) = self.active_tab_mut() {
+            tab.webview.notify_input_event(servo::InputEvent::MouseMove(
+                servo::MouseMoveEvent::new(point.into()),
+            ));
+        }
+    }
+
+    fn forward_mouse_click(&mut self, state: ElementState, button: winit::event::MouseButton) {
+        let pos = self.last_cursor_pos;
+        let inside = self.point_inside_content(pos);
+        if inside {
+            self.content_focused = true;
+            let point = self.content_point(pos);
+            if let Some(tab) = self.active_tab_mut() {
+                tab.webview.focus();
+                if let Some(btn) = winit_button_to_servo(button) {
+                    let action = winit_button_action_to_servo(state);
+                    tab.webview.notify_input_event(servo::InputEvent::MouseButton(
+                        servo::MouseButtonEvent::new(action, btn, point.into()),
+                    ));
+                }
+            }
+        } else if state == ElementState::Pressed {
+            self.content_focused = false;
+            if let Some(tab) = self.active_tab_mut() {
+                tab.webview.blur();
+            }
+        }
+    }
+
+    fn forward_wheel(&mut self, delta: winit::event::MouseScrollDelta) {
+        if !self.point_inside_content(self.last_cursor_pos) {
+            return;
+        }
+        let point = self.content_point(self.last_cursor_pos);
+        if let Some(tab) = self.active_tab_mut() {
+            if let Some(event) = wheel_input(delta, point) {
+                tab.webview.notify_input_event(event);
+            }
+        }
+    }
+
+    fn forward_keyboard(&mut self, event: &winit::event::KeyEvent) {
+        if !self.content_focused || self.url_bar_focused {
+            return;
+        }
+        let parts = servo_host::winit_key_event_to_parts(event);
+        if let Some(input) = make_keyboard_input(parts, self.modifiers) {
+            if let Some(tab) = self.active_tab_mut() {
+                tab.webview.notify_input_event(input);
+            }
+        }
+    }
+
+    fn redraw(&mut self) {
+        let Some(window) = self.window.clone() else {
+            return;
+        };
+        let Some(engine) = self.engine.clone() else {
+            return;
+        };
+
+        engine.spin();
+        self.drain_engine_messages();
+        if let Some(index) = self.pending_close.take() {
+            self.close_tab(index);
+        }
+        self.sync_viewport_and_paint();
+
+        let (screen, raw_input, egui_ctx) = {
+            let Some(gpu) = self.gpu.as_mut() else {
+                return;
+            };
+            let screen = ScreenDescriptor {
+                size_in_pixels: [gpu.config.width, gpu.config.height],
+                pixels_per_point: window.scale_factor() as f32,
+            };
+            let raw_input = gpu.egui_winit.take_egui_input(&window);
+            (screen, raw_input, gpu.egui_ctx.clone())
+        };
+
+        let mut full_output = egui_ctx.run_ui(raw_input, |ui| {
+            self.build_ui(ui);
+        });
+        let paint_jobs = egui_ctx.tessellate(full_output.shapes, full_output.pixels_per_point);
+
+        let Some(gpu) = self.gpu.as_mut() else {
+            return;
+        };
+        gpu.egui_winit
+            .handle_platform_output(&window, full_output.platform_output);
+
+        for (id, deltas) in &full_output.textures_delta.set {
+            for delta in deltas {
+                gpu.renderer.update_texture(&gpu.device, &gpu.queue, *id, delta);
+            }
+        }
+
+        let surface_texture = match gpu.surface.get_current_texture() {
+            wgpu::CurrentSurfaceTexture::Success(texture) => texture,
+            wgpu::CurrentSurfaceTexture::Suboptimal(texture) => {
+                gpu.surface.configure(&gpu.device, &gpu.config);
+                texture
+            }
+            other => {
+                log::warn!("get_current_texture: {other:?}");
+                window.request_redraw();
+                return;
+            }
+        };
+        let view = surface_texture
+            .texture
+            .create_view(&wgpu::TextureViewDescriptor::default());
+        let mut encoder = gpu
+            .device
+            .create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
+
+        let buffers = gpu.renderer.update_buffers(
+            &gpu.device,
+            &gpu.queue,
+            &mut encoder,
+            &paint_jobs,
+            &screen,
+        );
+
+        {
+            let clear = wgpu::Color {
+                r: CHROME_BG.r() as f64 / 255.0,
+                g: CHROME_BG.g() as f64 / 255.0,
+                b: CHROME_BG.b() as f64 / 255.0,
+                a: 1.0,
+            };
+            let pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                label: Some("fox-frame"),
+                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                    view: &view,
+                    depth_slice: None,
+                    resolve_target: None,
+                    ops: wgpu::Operations {
+                        load: wgpu::LoadOp::Clear(clear),
+                        store: wgpu::StoreOp::Store,
+                    },
+                })],
+                depth_stencil_attachment: None,
+                timestamp_writes: None,
+                occlusion_query_set: None,
+                multiview_mask: None,
+            });
+            let mut pass = pass.forget_lifetime();
+            gpu.renderer.render(&mut pass, &paint_jobs, &screen);
+        }
+
+        for id in &full_output.textures_delta.free {
+            gpu.renderer.free_texture(id);
+        }
+        full_output.textures_delta.clear();
+
+        gpu.queue.submit(
+            buffers
+                .into_iter()
+                .chain(std::iter::once(encoder.finish())),
+        );
+        gpu.queue.present(surface_texture);
+    }
+}
+
+fn nav_button(ui: &mut egui::Ui, glyph: &str, tip: &str) -> egui::Response {
+    ui.add(
+        egui::Button::new(egui::RichText::new(glyph).size(15.0))
+            .min_size(egui::vec2(30.0, 26.0))
+            .corner_radius(5.0),
+    )
+    .on_hover_text(tip)
+}
+
+fn truncate_title(title: &str, max_chars: usize) -> String {
+    if title.chars().count() <= max_chars {
+        title.to_owned()
+    } else {
+        let cut: String = title.chars().take(max_chars.saturating_sub(1)).collect();
+        format!("{cut}…")
+    }
+}
+
+fn fallback_title(url: &str) -> String {
+    Url::parse(url)
+        .ok()
+        .and_then(|u| u.host_str().map(|h| h.to_owned()))
+        .unwrap_or_else(|| "New Tab".to_owned())
+}
+
+pub fn parse_location(input: &str) -> Option<Url> {
+    let text = input.trim();
+    if text.is_empty() {
+        return None;
+    }
+    if text.starts_with("about:") || text.contains("://") {
+        return Url::parse(text).ok();
+    }
+    if text == "localhost" || text.starts_with("localhost:") || text.starts_with("127.0.0.1") {
+        return Url::parse(&format!("http://{text}")).ok();
+    }
+    let looks_like_host = !text.contains(char::is_whitespace) && (text.contains('.') || text.ends_with('/'));
+    if looks_like_host {
+        return Url::parse(&format!("https://{text}")).ok();
+    }
+    Url::parse_with_params("https://duckduckgo.com/", &[("q", text)]).ok()
+}
+
+impl ApplicationHandler<UserEvent> for BrowserApp {
+    fn resumed(&mut self, event_loop: &ActiveEventLoop) {
+        if self.window.is_none() {
+            if let Err(err) = self.init(event_loop) {
+                log::error!("Failed to initialize: {err}");
+                event_loop.exit();
+            }
+        }
+        event_loop.set_control_flow(ControlFlow::Wait);
+    }
+
+    fn exiting(&mut self, _event_loop: &ActiveEventLoop) {
+        // Close all WebViews while the Servo instance is still alive, so their
+        // shutdown messages reach a running constellation instead of a dying one.
+        if let Some(engine) = self.engine.take() {
+            engine.spin();
+            self.drain_engine_messages();
+        }
+        self.tabs.clear();
+    }
+
+    fn window_event(
+        &mut self,
+        event_loop: &ActiveEventLoop,
+        window_id: WindowId,
+        event: WindowEvent,
+    ) {        let Some(window) = self.window.clone() else {
+            return;
+        };
+        if window_id != window.id() {
+            return;
+        }
+
+        match &event {
+            WindowEvent::CloseRequested => event_loop.exit(),
+            WindowEvent::RedrawRequested => self.redraw(),
+            WindowEvent::Resized(size) => {
+                if let Some(gpu) = self.gpu.as_mut() {
+                    gpu.config.width = size.width.max(1);
+                    gpu.config.height = size.height.max(1);
+                    gpu.surface.configure(&gpu.device, &gpu.config);
+                }
+                if let Some(tab) = self.active_tab_mut() {
+                    tab.dirty = true;
+                }
+                window.request_redraw();
+            }
+            WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
+                self.scale_factor = *scale_factor;
+                for tab in &self.tabs {
+                    tab.webview
+                        .set_hidpi_scale_factor(euclid::Scale::new(*scale_factor as f32));
+                }
+            }
+            WindowEvent::CursorMoved { position, .. } => {
+                self.last_cursor_pos = *position;
+                self.forward_pointer_move();
+            }
+            WindowEvent::MouseInput { state, button, .. } => {
+                self.forward_mouse_click(*state, *button);
+            }
+            WindowEvent::MouseWheel { delta, .. } => self.forward_wheel(*delta),
+            WindowEvent::KeyboardInput {
+                event: key_event,
+                is_synthetic,
+                ..
+            } => {
+                if !*is_synthetic {
+                    self.forward_keyboard(key_event);
+                }
+            }
+            WindowEvent::ModifiersChanged(mods) => {
+                let state = mods.state();
+                let mut m = Modifiers::empty();
+                if state.contains(winit::keyboard::ModifiersState::SHIFT) {
+                    m |= Modifiers::SHIFT;
+                }
+                if state.contains(winit::keyboard::ModifiersState::CONTROL) {
+                    m |= Modifiers::CONTROL;
+                }
+                if state.contains(winit::keyboard::ModifiersState::ALT) {
+                    m |= Modifiers::ALT;
+                }
+                if state.contains(winit::keyboard::ModifiersState::SUPER) {
+                    m |= Modifiers::META;
+                }
+                self.modifiers = m;
+            }
+            _ => {}
+        }
+
+        if let Some(gpu) = self.gpu.as_mut() {
+            let response = gpu.egui_winit.on_window_event(&window, &event);
+            if response.repaint {
+                window.request_redraw();
+            }
+        }
+    }
+
+    fn user_event(&mut self, event_loop: &ActiveEventLoop, event: UserEvent) {
+        match event {
+            UserEvent::RepaintAfter(delay) => {
+                event_loop.set_control_flow(ControlFlow::WaitUntil(Instant::now() + delay));
+                if let Some(window) = self.window.as_ref() {
+                    window.request_redraw();
+                }
+            }
+        }
+    }
+}

src/main.rs

@@ -0,0 +1,30 @@
+mod app;
+mod servo_host;
+
+use std::error::Error;
+
+use app::BrowserApp;
+
+#[derive(Debug)]
+pub enum UserEvent {
+    RepaintAfter(std::time::Duration),
+}
+
+fn main() -> Result<(), Box<dyn Error>> {
+    // Note: logging is initialized by `Servo::setup_logging()` — do not install
+    // another logger here or it will panic with `SetLoggerError`.
+
+    rustls::crypto::aws_lc_rs::default_provider()
+        .install_default()
+        .expect("Failed to install crypto provider");
+
+    let event_loop = winit::event_loop::EventLoop::<UserEvent>::with_user_event()
+        .build()
+        .expect("Failed to create event loop");
+
+    let proxy = event_loop.create_proxy();
+    let mut app = BrowserApp::new(proxy);
+
+    event_loop.run_app(&mut app)?;
+    Ok(())
+}

src/servo_host.rs

@@ -0,0 +1,303 @@
+use std::cell::RefCell;
+use std::rc::Rc;
+
+use egui::TextureHandle;
+use keyboard_types::{Code, Key, KeyState, Location, Modifiers, NamedKey};
+use servo::{
+    DevicePoint, EventLoopWaker, InputEvent, KeyboardEvent as ServoKeyboardEvent, LoadStatus,
+    MouseButton, MouseButtonAction, OffscreenRenderingContext, RenderingContext, Servo,
+    ServoBuilder, Theme, WebView, WebViewBuilder, WebViewId, WheelDelta, WheelEvent, WheelMode,
+    WindowRenderingContext,
+};
+use url::Url;
+
+pub type SharedQueue = Rc<RefCell<Vec<EngineMsg>>>;
+
+pub enum EngineMsg {
+    UrlChanged(WebViewId, String),
+    TitleChanged(WebViewId, Option<String>),
+    StatusText(WebViewId, Option<String>),
+    LoadStatus(WebViewId, bool),
+    NewFrame(WebViewId),
+    Animating(WebViewId, bool),
+    Crashed(WebViewId, String),
+    Closed(WebViewId),
+    NewWebView(WebView),
+}
+
+#[derive(Clone)]
+pub struct EguiWaker(pub egui::Context);
+
+impl EventLoopWaker for EguiWaker {
+    fn clone_box(&self) -> Box<dyn EventLoopWaker> {
+        Box::new(self.clone())
+    }
+
+    fn wake(&self) {
+        self.0.request_repaint();
+    }
+}
+
+pub struct BrowserDelegate {
+    pub queue: SharedQueue,
+}
+
+impl servo::WebViewDelegate for BrowserDelegate {
+    fn notify_url_changed(&self, webview: WebView, url: Url) {
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::UrlChanged(webview.id(), url.to_string()));
+    }
+
+    fn notify_page_title_changed(&self, webview: WebView, title: Option<String>) {
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::TitleChanged(webview.id(), title));
+    }
+
+    fn notify_status_text_changed(&self, webview: WebView, status: Option<String>) {
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::StatusText(webview.id(), status));
+    }
+
+    fn notify_load_status_changed(&self, webview: WebView, status: LoadStatus) {
+        let loading = !matches!(status, LoadStatus::Complete);
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::LoadStatus(webview.id(), loading));
+    }
+
+    fn notify_new_frame_ready(&self, webview: WebView) {
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::NewFrame(webview.id()));
+    }
+
+    fn notify_animating_changed(&self, webview: WebView, animating: bool) {
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::Animating(webview.id(), animating));
+    }
+
+    fn notify_crashed(&self, webview: WebView, reason: String, _backtrace: Option<String>) {
+        self.queue
+            .borrow_mut()
+            .push(EngineMsg::Crashed(webview.id(), reason));
+    }
+
+    fn notify_closed(&self, webview: WebView) {
+        self.queue.borrow_mut().push(EngineMsg::Closed(webview.id()));
+    }
+
+    fn request_create_new(&self, parent_webview: WebView, request: servo::CreateNewWebViewRequest) {
+        let webview = request
+            .builder(parent_webview.rendering_context())
+            .delegate(parent_webview.delegate())
+            .build();
+        webview.notify_theme_change(Theme::Light);
+        self.queue.borrow_mut().push(EngineMsg::NewWebView(webview));
+    }
+}
+
+pub struct Engine {
+    pub servo: Servo,
+    pub window_context: Rc<WindowRenderingContext>,
+    pub queue: SharedQueue,
+}
+
+impl Engine {
+    pub fn new(waker: EguiWaker, window_context: Rc<WindowRenderingContext>) -> Engine {
+        let queue: SharedQueue = Rc::new(RefCell::new(Vec::new()));
+        let servo = ServoBuilder::default()
+            .event_loop_waker(Box::new(waker))
+            .build();
+        servo.setup_logging();
+        Engine {
+            servo,
+            window_context,
+            queue,
+        }
+    }
+
+    pub fn spin(&self) {
+        self.servo.spin_event_loop();
+    }
+
+    pub fn create_tab(&self, url: Url, hidpi_scale: f32) -> Tab {
+        let size = self.window_context.size();
+        let offscreen: Rc<OffscreenRenderingContext> =
+            Rc::new(self.window_context.offscreen_context(size));
+        let delegate = Rc::new(BrowserDelegate {
+            queue: self.queue.clone(),
+        });
+        let webview = WebViewBuilder::new(&self.servo, offscreen as Rc<dyn RenderingContext>)
+            .url(url)
+            .hidpi_scale_factor(euclid::Scale::new(hidpi_scale))
+            .delegate(delegate)
+            .build();
+        webview.notify_theme_change(Theme::Light);
+        Tab::new(webview)
+    }
+}
+
+pub struct Tab {
+    pub webview: WebView,
+    pub id: WebViewId,
+    pub title: String,
+    pub url_string: String,
+    pub status_text: Option<String>,
+    pub loading: bool,
+    pub animating: bool,
+    pub dirty: bool,
+    pub texture: Option<TextureHandle>,
+    /// Hash of the last uploaded frame — skips redundant GPU texture uploads.
+    pub last_frame_hash: u64,
+    /// Time of the last GPU->CPU readback — throttles readback frequency.
+    pub last_paint: std::time::Instant,
+}
+
+impl Tab {
+    fn new(webview: WebView) -> Tab {
+        Tab {
+            id: webview.id(),
+            webview,
+            title: String::from("New Tab"),
+            url_string: String::new(),
+            status_text: None,
+            loading: true,
+            animating: false,
+            dirty: true,
+            texture: None,
+            last_frame_hash: 0,
+            last_paint: std::time::Instant::now() - std::time::Duration::from_secs(1),
+        }
+    }
+
+    pub fn adopt(webview: WebView) -> Tab {
+        Tab::new(webview)
+    }
+}
+
+fn winit_named_key_to_kt(key: winit::keyboard::NamedKey) -> Key {
+    use winit::keyboard::NamedKey as W;
+    match key {
+        W::Enter => Key::Named(NamedKey::Enter),
+        W::Tab => Key::Named(NamedKey::Tab),
+        W::Backspace => Key::Named(NamedKey::Backspace),
+        W::Delete => Key::Named(NamedKey::Delete),
+        W::Escape => Key::Named(NamedKey::Escape),
+        W::Space => Key::Character(" ".into()),
+        W::ArrowUp => Key::Named(NamedKey::ArrowUp),
+        W::ArrowDown => Key::Named(NamedKey::ArrowDown),
+        W::ArrowLeft => Key::Named(NamedKey::ArrowLeft),
+        W::ArrowRight => Key::Named(NamedKey::ArrowRight),
+        W::Home => Key::Named(NamedKey::Home),
+        W::End => Key::Named(NamedKey::End),
+        W::PageUp => Key::Named(NamedKey::PageUp),
+        W::PageDown => Key::Named(NamedKey::PageDown),
+        W::Insert => Key::Named(NamedKey::Insert),
+        W::F1 => Key::Named(NamedKey::F1),
+        W::F2 => Key::Named(NamedKey::F2),
+        W::F3 => Key::Named(NamedKey::F3),
+        W::F4 => Key::Named(NamedKey::F4),
+        W::F5 => Key::Named(NamedKey::F5),
+        W::F6 => Key::Named(NamedKey::F6),
+        W::F7 => Key::Named(NamedKey::F7),
+        W::F8 => Key::Named(NamedKey::F8),
+        W::F9 => Key::Named(NamedKey::F9),
+        W::F10 => Key::Named(NamedKey::F10),
+        W::F11 => Key::Named(NamedKey::F11),
+        W::F12 => Key::Named(NamedKey::F12),
+        _ => Key::Named(NamedKey::Unidentified),
+    }
+}
+
+pub fn winit_key_to_kt_key(key: &winit::keyboard::Key) -> Key {
+    match key {
+        winit::keyboard::Key::Character(s) => Key::Character(s.as_str().into()),
+        winit::keyboard::Key::Named(n) => winit_named_key_to_kt(*n),
+        _ => Key::Named(NamedKey::Unidentified),
+    }
+}
+
+pub struct KeyEventParts {
+    pub state: KeyState,
+    pub key: Key,
+    pub code: Code,
+    pub repeat: bool,
+}
+
+pub fn winit_key_event_to_parts(event: &winit::event::KeyEvent) -> KeyEventParts {
+    let state = if event.state == winit::event::ElementState::Pressed {
+        KeyState::Down
+    } else {
+        KeyState::Up
+    };
+    let code = match event.physical_key {
+        winit::keyboard::PhysicalKey::Code(code) => {
+            // winit's `KeyCode` variants share their names with the W3C
+            // `KeyboardEvent.code` values that `keyboard_types::Code` parses.
+            format!("{code:?}")
+                .parse::<Code>()
+                .unwrap_or(Code::Unidentified)
+        }
+        winit::keyboard::PhysicalKey::Unidentified(_native) => Code::Unidentified,
+    };
+    KeyEventParts {
+        state,
+        key: winit_key_to_kt_key(&event.logical_key),
+        code,
+        repeat: event.repeat,
+    }
+}
+
+pub fn make_keyboard_input(parts: KeyEventParts, modifiers: Modifiers) -> Option<InputEvent> {
+    if parts.key == Key::Named(NamedKey::Unidentified) && parts.code == Code::Unidentified {
+        return None;
+    }
+    let event = ServoKeyboardEvent::new_without_event(
+        parts.state,
+        parts.key,
+        parts.code,
+        Location::Standard,
+        modifiers,
+        parts.repeat,
+        false,
+    );
+    Some(InputEvent::Keyboard(event))
+}
+
+pub fn winit_button_to_servo(button: winit::event::MouseButton) -> Option<MouseButton> {
+    match button {
+        winit::event::MouseButton::Left => Some(MouseButton::Left),
+        winit::event::MouseButton::Right => Some(MouseButton::Right),
+        winit::event::MouseButton::Middle => Some(MouseButton::Middle),
+        winit::event::MouseButton::Back => Some(MouseButton::Back),
+        winit::event::MouseButton::Forward => Some(MouseButton::Forward),
+        winit::event::MouseButton::Other(_) => None,
+    }
+}
+
+pub fn winit_button_action_to_servo(state: winit::event::ElementState) -> MouseButtonAction {
+    match state {
+        winit::event::ElementState::Pressed => MouseButtonAction::Down,
+        winit::event::ElementState::Released => MouseButtonAction::Up,
+    }
+}
+
+pub fn wheel_input(
+    delta: winit::event::MouseScrollDelta,
+    point: DevicePoint,
+) -> Option<InputEvent> {
+    let (x, y, mode) = match delta {
+        winit::event::MouseScrollDelta::LineDelta(dx, dy) => {
+            ((dx * 76.0) as f64, (dy * 76.0) as f64, WheelMode::DeltaLine)
+        }
+        winit::event::MouseScrollDelta::PixelDelta(pos) => (pos.x, pos.y, WheelMode::DeltaPixel),
+    };
+    Some(InputEvent::Wheel(WheelEvent::new(
+        WheelDelta { x, y, z: 0.0, mode },
+        point.into(),
+    )))
+}