🐛 fix: fix: improve viewer startup and integrated webapp loading

  - Improve integrated WebKit viewer performance settings
  - Add dark centered loading overlay for viewer startup
  - Reveal committed long-loading pages without waiting for full load finish
  - Delay initial URL load until the window and signal handlers are ready
  - Add one-time startup recovery reload for persisted sessions that reopen blank
  - Reduce startup recovery delay to 1s for faster YouTube reopen behavior
  - Update release metadata and bump version to 4.0.6

Author: talesam

Cargo.lock

@@ -8,7 +8,7 @@ members = [
 ]
 
 [workspace.package]
-version = "4.0.1"
+version = "4.0.6"
 edition = "2021"
 license = "GPL-3.0-or-later"
 repository = "https://github.com/biglinux/biglinux-webapps"

Cargo.toml

@@ -462,6 +462,31 @@
     <control>touch</control>
   </supports>
   <releases>
+    <release version="4.0.6" date="2026-05-16">
+      <description>
+        <p>Reduces the integrated viewer startup recovery delay so stalled persisted sessions reload faster.</p>
+      </description>
+    </release>
+    <release version="4.0.5" date="2026-05-16">
+      <description>
+        <p>Adds a one-time startup recovery reload for integrated-viewer pages that reopen from a persisted session but remain blank, matching the manual reload needed by YouTube.</p>
+      </description>
+    </release>
+    <release version="4.0.4" date="2026-05-16">
+      <description>
+        <p>Fixes the integrated viewer startup sequence so complex pages such as YouTube start loading only after the window and loading overlay are fully connected.</p>
+      </description>
+    </release>
+    <release version="4.0.3" date="2026-05-16">
+      <description>
+        <p>Simplifies the integrated viewer loading indicator, centers it reliably, and reveals long-running pages such as YouTube as soon as content is committed.</p>
+      </description>
+    </release>
+    <release version="4.0.2" date="2026-05-16">
+      <description>
+        <p>Optimizes the integrated WebKit viewer with tighter cache and memory pressure settings, enables hardware acceleration, and replaces the blank initial page with a dark neon loading overlay.</p>
+      </description>
+    </release>
     <release version="4.0.1" date="2026-05-16">
       <description>
         <p>Fixes Wayland desktop IDs and icon mapping for browser-backed webapps, preserves integrated-viewer profiles across ID migrations, improves favicon quality selection, and refines auto-hidden headerbar and media playback behavior.</p>

biglinux-webapps/usr/share/metainfo/br.com.biglinux.webapps.metainfo.xml

@@ -4,7 +4,7 @@ use gtk4 as gtk;
 use libadwaita as adw;
 use webkit6 as webkit;
 
-use super::settings;
+use super::{loading, settings};
 
 pub(super) struct ViewerChrome {
     pub title_widget: adw::WindowTitle,
@@ -52,7 +52,8 @@ pub(super) fn build_chrome(name: &str, url: &str, webview: &webkit::WebView) ->
     let toolbar = adw::ToolbarView::new();
     toolbar.add_top_bar(&header);
     toolbar.add_top_bar(&url_bar);
-    toolbar.set_content(Some(webview));
+    let content = loading::build_loading_overlay(webview);
+    toolbar.set_content(Some(&content));
     toolbar.set_reveal_top_bars(true);
 
     ViewerChrome {

crates/webapps-viewer/src/window/chrome.rs

@@ -0,0 +1,172 @@
+use std::{cell::Cell, rc::Rc, sync::Once, time::Duration};
+
+use glib::clone;
+use gtk4 as gtk;
+use gtk4::gdk;
+use gtk4::prelude::*;
+use webkit6 as webkit;
+use webkit6::prelude::*;
+
+const CONTENT_REVEAL_DELAY_MS: u64 = 250;
+
+const CSS: &str = r#"
+.viewer-loading {
+    background-color: #03040a;
+}
+
+.viewer-loading-spinner {
+    color: #d4d5df;
+    min-width: 72px;
+    min-height: 72px;
+}
+"#;
+
+static CSS_LOADED: Once = Once::new();
+
+pub(super) fn build_loading_overlay(webview: &webkit::WebView) -> gtk::Overlay {
+    load_css();
+
+    let overlay = gtk::Overlay::new();
+    overlay.set_child(Some(webview));
+
+    let veil = gtk::Box::new(gtk::Orientation::Vertical, 0);
+    veil.add_css_class("viewer-loading");
+    veil.set_can_target(false);
+    veil.set_halign(gtk::Align::Fill);
+    veil.set_valign(gtk::Align::Fill);
+    veil.set_hexpand(true);
+    veil.set_vexpand(true);
+
+    let spinner = gtk::Spinner::new();
+    spinner.add_css_class("viewer-loading-spinner");
+    spinner.set_can_target(false);
+    spinner.set_halign(gtk::Align::Center);
+    spinner.set_valign(gtk::Align::Center);
+    spinner.start();
+
+    overlay.add_overlay(&veil);
+    overlay.add_overlay(&spinner);
+
+    let generation = Rc::new(Cell::new(0_u64));
+    connect_loading_state(webview, &veil, &spinner, &generation);
+    sync_initial_state(webview, &veil, &spinner, &generation);
+
+    overlay
+}
+
+fn load_css() {
+    CSS_LOADED.call_once(|| {
+        let provider = gtk::CssProvider::new();
+        provider.load_from_data(CSS);
+
+        if let Some(display) = gdk::Display::default() {
+            gtk::style_context_add_provider_for_display(
+                &display,
+                &provider,
+                gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+            );
+        }
+    });
+}
+
+fn connect_loading_state(
+    webview: &webkit::WebView,
+    veil: &gtk::Box,
+    spinner: &gtk::Spinner,
+    generation: &Rc<Cell<u64>>,
+) {
+    webview.connect_load_changed(clone!(
+        #[weak]
+        veil,
+        #[weak]
+        spinner,
+        #[strong]
+        generation,
+        move |_, event| match event {
+            webkit::LoadEvent::Started | webkit::LoadEvent::Redirected => {
+                show_loading(&veil, &spinner, &generation);
+            }
+            webkit::LoadEvent::Committed => schedule_hide(&veil, &spinner, &generation),
+            webkit::LoadEvent::Finished => {
+                hide_loading(&veil, &spinner);
+            }
+            _ => {}
+        }
+    ));
+
+    webview.connect_load_failed(clone!(
+        #[weak]
+        veil,
+        #[weak]
+        spinner,
+        #[strong]
+        generation,
+        #[upgrade_or]
+        false,
+        move |_, _, _, _| {
+            generation.set(generation.get().wrapping_add(1));
+            hide_loading(&veil, &spinner);
+            false
+        }
+    ));
+
+    webview.connect_estimated_load_progress_notify(clone!(
+        #[weak]
+        veil,
+        #[weak]
+        spinner,
+        #[strong]
+        generation,
+        move |wv| {
+            if wv.estimated_load_progress() >= 0.35 {
+                schedule_hide(&veil, &spinner, &generation);
+            }
+        }
+    ));
+}
+
+fn sync_initial_state(
+    webview: &webkit::WebView,
+    veil: &gtk::Box,
+    spinner: &gtk::Spinner,
+    generation: &Rc<Cell<u64>>,
+) {
+    if webview.is_loading() || webview.estimated_load_progress() < 1.0 {
+        show_loading(veil, spinner, generation);
+    } else {
+        hide_loading(veil, spinner);
+    }
+}
+
+fn show_loading(veil: &gtk::Box, spinner: &gtk::Spinner, generation: &Rc<Cell<u64>>) {
+    generation.set(generation.get().wrapping_add(1));
+    veil.set_visible(true);
+    spinner.set_visible(true);
+    spinner.start();
+}
+
+fn schedule_hide(veil: &gtk::Box, spinner: &gtk::Spinner, generation: &Rc<Cell<u64>>) {
+    let expected_generation = generation.get();
+    glib::timeout_add_local_once(
+        Duration::from_millis(CONTENT_REVEAL_DELAY_MS),
+        clone!(
+            #[weak]
+            veil,
+            #[weak]
+            spinner,
+            #[strong]
+            generation,
+            move || {
+                if generation.get() == expected_generation {
+                    hide_loading(&veil, &spinner);
+                }
+            }
+        ),
+    );
+}
+
+fn hide_loading(veil: &gtk::Box, spinner: &gtk::Spinner) {
+    spinner.stop();
+    spinner.set_visible(false);
+    veil.set_visible(false);
+}

crates/webapps-viewer/src/window/loading.rs

@@ -10,12 +10,14 @@ mod chrome;
 mod context_menu;
 mod downloads;
 mod geometry;
+mod loading;
 mod navigation;
 mod permissions;
 mod session;
 mod settings;
 mod shortcuts;
 mod shortcuts_window;
+mod startup;
 
 #[allow(unused_imports)]
 use adw::prelude::*;
@@ -34,7 +36,7 @@ pub fn build(
     app_id: &str,
     auto_hide_headerbar: bool,
 ) -> adw::ApplicationWindow {
-    let viewer_session = session::build_viewer_session(app_id, url);
+    let viewer_session = session::build_viewer_session(app_id);
     let chrome = chrome::build_chrome(name, url, &viewer_session.webview);
 
     let window = adw::ApplicationWindow::builder()
@@ -99,5 +101,7 @@ pub fn build(
         chrome.toolbar.set_reveal_top_bars(false);
     }
 
+    startup::connect_initial_load(&window, &viewer_session.webview, url);
+
     window
 }

crates/webapps-viewer/src/window/mod.rs

@@ -1,24 +1,40 @@
 use std::path::PathBuf;
 
+use gdk4 as gdk;
 use webkit6 as webkit;
 use webkit6::prelude::*;
 
 use webapps_core::config;
 
 use super::settings;
 
+const WEB_PROCESS_MEMORY_LIMIT_MB: u32 = 1024;
+const NETWORK_PROCESS_MEMORY_LIMIT_MB: u32 = 512;
+const MEMORY_PRESSURE_CONSERVATIVE_THRESHOLD: f64 = 0.50;
+const MEMORY_PRESSURE_STRICT_THRESHOLD: f64 = 0.75;
+const MEMORY_PRESSURE_POLL_INTERVAL_SECONDS: f64 = 30.0;
+
 pub(super) struct ViewerSession {
     pub session: webkit::NetworkSession,
     pub webview: webkit::WebView,
     pub data_dir: PathBuf,
 }
 
-pub(super) fn build_viewer_session(app_id: &str, url: &str) -> ViewerSession {
+pub(super) fn build_viewer_session(app_id: &str) -> ViewerSession {
     let data_dir = config::data_dir().join(app_id);
     let cache_dir = config::cache_dir().join(app_id);
     std::fs::create_dir_all(&data_dir).ok();
     std::fs::create_dir_all(&cache_dir).ok();
 
+    let mut network_pressure = memory_pressure_settings(NETWORK_PROCESS_MEMORY_LIMIT_MB);
+    webkit::NetworkSession::set_memory_pressure_settings(&mut network_pressure);
+
+    let web_pressure = memory_pressure_settings(WEB_PROCESS_MEMORY_LIMIT_MB);
+    let web_context = webkit::WebContext::builder()
+        .memory_pressure_settings(&web_pressure)
+        .build();
+    web_context.set_cache_model(webkit::CacheModel::DocumentBrowser);
+
     let session = webkit::NetworkSession::new(
         Some(data_dir.to_str().unwrap_or_default()),
         Some(cache_dir.to_str().unwrap_or_default()),
@@ -34,10 +50,14 @@ pub(super) fn build_viewer_session(app_id: &str, url: &str) -> ViewerSession {
         cookie_manager.set_accept_policy(webkit::CookieAcceptPolicy::Always);
     }
 
-    let webview = webkit::WebView::builder().network_session(&session).build();
+    let webview = webkit::WebView::builder()
+        .web_context(&web_context)
+        .network_session(&session)
+        .build();
+    let background = gdk::RGBA::new(0.012, 0.014, 0.030, 1.0);
+    webview.set_background_color(&background);
     settings::configure_settings(&webview);
     settings::inject_resize_block(&webview);
-    webview.load_uri(url);
     webview.set_vexpand(true);
     webview.set_hexpand(true);
 
@@ -47,3 +67,13 @@ pub(super) fn build_viewer_session(app_id: &str, url: &str) -> ViewerSession {
         data_dir,
     }
 }
+
+fn memory_pressure_settings(limit_mb: u32) -> webkit::MemoryPressureSettings {
+    let mut pressure = webkit::MemoryPressureSettings::new();
+    pressure.set_memory_limit(limit_mb);
+    pressure.set_conservative_threshold(MEMORY_PRESSURE_CONSERVATIVE_THRESHOLD);
+    pressure.set_strict_threshold(MEMORY_PRESSURE_STRICT_THRESHOLD);
+    pressure.set_kill_threshold(0.0);
+    pressure.set_poll_interval(MEMORY_PRESSURE_POLL_INTERVAL_SECONDS);
+    pressure
+}

crates/webapps-viewer/src/window/session.rs

@@ -34,9 +34,10 @@ pub(super) fn configure_settings(webview: &webkit::WebView) {
         s.set_enable_encrypted_media(true);
         s.set_enable_site_specific_quirks(true);
         s.set_enable_html5_local_storage(true);
-        s.set_enable_page_cache(true);
+        s.set_enable_page_cache(false);
         s.set_enable_smooth_scrolling(true);
         s.set_enable_back_forward_navigation_gestures(true);
+        s.set_hardware_acceleration_policy(webkit::HardwareAccelerationPolicy::Always);
         // spoof Chrome UA → sites like Spotify/Teams reject unknown browsers
         s.set_user_agent(Some(SPOOFED_UA));
     }