WebKitGTK and WPE WebKit: Current Status and Future on Linux Devices

Igalia

Introduction [0:05]

• About the Speaker: Mario Sanchez-Prada [0:30]
  • Software Engineer and partner at Igalia.
  • Extensive experience in Open Source work: GNOME, Chromium/Blink, WebKit.
  • Worked on Linux-based operating systems like Maemo, Endless OS, and Samsung Smart TV.
  • Currently coordinating Igalia's WebKit team.
• About Igalia [1:05]
  • Founded in A Coruña (Spain) in 2001.
  • Specialized Open Source consultancy, fully remote with a flat structure.
  • Second-largest contributor to main Open Source Web Rendering Engines.
  • Other OSS work: kernel, compilers, multimedia, graphics, drivers, and members of various Working Groups (W3C, WHATWG, TC39, Test262, Khronos).

Understanding Web Rendering Engines and WebKit [2:27]

• What is a Web Rendering Engine? [2:27]
  • Fetches HTML/CSS/JavaScript content from multiple sources.
  • Interprets web content to create an internal representation.
  • Renders a result that users can interact with.
• Main Web Rendering Engines [2:50]
  • WebKit (used by Safari, Mail, App Store)
  • Blink (forked from WebKit by Google in 2013, used by Chromium-based browsers)
  • Gecko (used by Firefox)
  • Servo (an emerging engine)
• What is WebKit? [3:17]
  • An Open Source Web rendering engine since 2005.
  • Forked from KHTML and KJS by Apple in 2001.
  • Forked again by Google in 2013 (Blink).
  • Main goals: Performance, portability, stability, compatibility, standards compliance, security, hackability, and embeddability.
  • Support for different platforms:
    • Desktop & Mobile: Mac, iOS, Linux, Windows.
    • Embedded: set-top boxes, gaming consoles, smart home appliances, IVI systems, GPS navigation, digital signage.
  • Multi-process architecture: UI Process, Web Process, Network Process, GPU Process.
• Advantages of WebKit [4:38]
  • Complete implementation of the Web Platform.
  • Embeddable as top priority (designed to be used in various platforms and systems).
  • Flexible and modular architecture.
  • High performance and stability.
  • Privacy and security by design.
  • Independent Linux-based flavors (not controlled by any big corporation).
• WebKit Architecture [5:34]
  • Application: What end-users interact with.
  • WebKit: Exposes a public API to applications and implements the multi-process model.
  • WebCore: Handles HTML/CSS parsing, rendering, layout, painting, network, multimedia, accessibility.
  • JavaScriptCore: JavaScript engine (supports WebAssembly).
  • Platform: Platform-specific hooks and low-level plumbing (e.g., OpenGL, Skia, GStreamer, libsoup, fontconfig).
• WebKit Ports [6:24]
  • WebKit port is an adaptation of WebKit to a platform.
  • Official WebKit Ports (upstream ports):
    • Mac: Safari, Apple Mail, iTunes, App Store.
    • iOS: Web browsers on iOS devices (also Chrome).
    • Windows: Microsoft Playwright, PlayStation SDK.
    • PlayStation: PlayStation 4 & PlayStation 5.
    • WebKitGTK: GNOME Web, Evolution, Shotwell.
    • WPE WebKit: Custom "browsers" for embedded devices.

WebKitGTK and WPE WebKit [7:10]

• What is WebKitGTK? [7:10]
  • Port of WebKit for Linux-based GTK applications.
  • Fully-featured implementation of the Web Platform.
    • Support for HW-accelerated graphics and multimedia.
  • Used in a wide variety of GTK applications: GNOME Web (browser), Evolution (mail client), GNOME Builder (IDE).
  • Provides a widget (WebKitWebView) to be used in GTK applications, offering a public API to interact with the web engine and respond to events.
  • Platform-specific functionality implemented on top of other components (e.g., Skia, OpenGL, EGL, GStreamer, libsoup, fontconfig, harfbuzz).
  • Fully operational JavaScript engine (JavaScriptCore).
• What is WPE WebKit? [8:31]
  • Port of WebKit for Linux-based embedded devices (WPE = Web Platform for Embedded).
  • Shared architecture with WebKitGTK (common parts: GLib, Skia, GStreamer, libsoup, fontconfig).
  • Key differences: no UI toolkit, graphics stack, input handling (focus on flexibility).
  • Minimal set of dependencies.
  • Backend-based architecture for I/O (graphics, input devices).
  • Low memory and storage footprint.
  • Platform-specific HW-acceleration (to relieve CPU).

Importance of Web Rendering Engines in Embedded Devices [10:55]

• Strategic Role in the Software Stack of Embedded Devices [10:55]
  • Handles rendering, networking, security sandbox, media, I/O, accessibility.
  • The Web Platform allows building all sorts of applications, offering flexibility for designing, implementing, and testing products.
• Known Development Stack [11:24]
  • Massive pool of web developers can implement applications.
  • Useful to implement all kinds of products (Smart home, In-Vehicle/Flight infotainment, digital signage, Hi-Fi sound systems, audio streaming, server-side rendering, QA and testing).
• WebKit on Embedded Devices [11:33]
  • Phones & tablets, set-top boxes & TVs (hundreds of millions of devices), smart home appliances, GPS navigation devices, audio/video conferencing.
  • Even cooking machines, fridges, audio systems without screens.

History of WebKitGTK & WPE WebKit [12:15]

• 2007: WebKitGTK is born. [12:33]
  • GNOME's Epiphany browser previously used Gecko, but its API was not suitable for embedding in different applications without breaking changes.
  • Arnt Locker from the GNOME community started WebKitGTK as a replacement for Gecko in Epiphany.
• 2009: WebKitGTK replaces libcurl with libsoup, and Gecko in Epiphany. [13:21]
• 2010: The WebKit2 project is announced, and WebKitGTK starts work on WebKit2. [13:40]
  • WebKitGTK initially had a single process, meaning a crash in web content would crash the entire browser. WebKit2 aimed to introduce a multi-process architecture for better stability.
• 2013: First stable version of WebKitGTK with WebKit2 in GNOME 3.8. [14:20]
• 2014: Support for WebKit1 is removed. WPE is born as "WebKit For Wayland". [14:31]
  • The idea was to remove GTK from WebKitGTK to make it more friendly for embedded devices.
  • The environment where this idea originated was using Wayland, so it was conceived to use Wayland directly for rendering.
• 2017: "WebKit For Wayland" is renamed to WPE WebKit and becomes an official part of WebKit, moving upstream. [15:42]
  • WPE gained massive adoption in the embedded space (millions of devices).
• 2022: Start of major refactorings on the architecture of the ports. WPE Android efforts restarted. [16:04]
  • Addressing issues with 2D rendering (Cairo was not hardware-accelerated and poorly maintained).
  • Exploring moving to Skia for 2D rendering.
  • Restarting efforts to run WPE on Android devices.
• 2023: WebGL2 support with ANGLE, initial dma-buf support, initial GPUProcess support. [17:05]
  • Significant progress in graphics and buffer sharing.
• 2024: Migration from Cairo to Skia. Initial implementation of the new WPEPlatform API. Progress on the new HW-accelerated SVG engine (Lottie). [17:28]
  • Major decision to move to Skia for hardware acceleration and better performance.
  • Developing a new, less complex WPEPlatform API.
• 2025: Massive refactorings in the graphics architecture of the 2 Linux ports. Maturity of the new WPEPlatform API. WPE Android moves to the new API. [18:27]
  • This period represents a "really good momentum" for WebKit on Linux.

Latest Updates [19:00]

• 2 new stable releases of WebKitGTK and WPE WebKit: [19:02]
  • Published in March [2] and September [2], as usual, with a six-month cadence.
  • Numerous updates and improvements in HTML, CSS, JS, and Web features.
• Multimedia-related improvements: [19:16]
  • WebM support in MediaRecorder, WebAudio fixes, WebCodecs compliance.
  • GStreamer-based WebRTC backends.
• Big overhaul to the graphics rendering pipeline: [19:24]
  • Major refactoring and removal of unused abstraction layers.
  • Threaded GPU rendering, GPUProcess for WebGL.
  • Damage tracking and propagation to the compositing stage.
  • Significant performance gains (e.g., 3x improvement on Raspberry Pi 4 overall score, with some tests showing 11x improvement).
• JavaScriptCore: [20:35]
  • Improved memory management for long-running applications.
  • New tooling to detect memory leaks and do profiling.
  • WASM-related work for 32-bit support (i.e., BBQJIT, OMG, IPInt).
• Security: [20:43]
  • Continuing with regular release cadence and handling security advisories.
  • Increased use of smart pointers, dropped libsoup2 support (using libsoup3).
• Quality assurance: [20:46]
  • Better infrastructure, improved test coverage.
  • Move the QA bots to the new WebKit Container SDK.
• New WPEPlatform API: [21:03]
  • Support for accessibility, multiple views, touch events in DRM platform.
  • GTK4 platform implementation via an external backend.
  • Multiple API additions and API tests. Integration with QA bots.
  • Aims for stable release in September 2025 (WPE 2.54).
• Android support: [21:30]
  • Upstreamed all patches from the WPE-Android project.
  • Added AHardwareBuffer support in WebKit upstream (equivalent to dma-buf for Android).
  • Native integration with Android subsystems (e.g., logging).
  • Kept evolving the WPE-Android project (WPE 2.50, NDK r27, WPEPlatform API).
• WebXR support: [22:07]
  • Implemented WebXR using OpenXR and added support for the WebXR AR module.
  • Enabled WebXR support on both Linux and Android.

Next Steps [22:25]

• Multimedia-related improvements: [22:33]
  • GStreamer-based WebRTC backend.
  • Screen capture streaming to WebRTC PeerConnection.
  • WebCodecs integration with WebGL and WebAudio.
  • Player suspension (useful in pages with many media elements).
• More work on the graphics rendering pipeline: [22:51]
  • Align the graphics architecture with other ports (Mac, iOS).
  • Compositor refactor to avoid OpenGL dependency and support new APIs (like Vulkan, opening door for WebGPU).
  • Improvements around async scrolling animations.
  • Enable GPUProcess in more cases (currently WebGL only).
  • Remove Cairo support (expected 2025).
• JavaScriptCore: [23:51]
  • Memory improvements for long-running applications.
  • Better tooling to investigate memory-related problems.
• Security: [23:57]
  • Keep working on the same release cadence and handling Security Advisories.
  • Smart pointer coverage, reduce instances of unsafe buffers access.
• Quality assurance: [24:12]
  • Better QA infrastructure and improve test coverage.
  • Resume the WebKit gardening efforts for the Linux ports.
• New WPEPlatform API: [24:28]
  • Complete the new WPEPlatform API.
  • Write more API tests and documentation.
  • Release version 1.0 (aiming for WPE 2.54).
• Android support: [24:37]
  • Complete migration to the new WPEPlatform API.
  • Integrate with the upstream testing infrastructure.
• WebXR support: [24:52]
  • Implement more WebXR modules.
  • Implement WebXR layers, hit test, and anchors.

Wrapping up [24:55]

• WebKit remains a complete and embeddable Web engine on Linux, with WebKitGTK for GTK-based applications and WPE WebKit for embedded devices.
• Both ports are mature, actively-maintained Linux ports, having seen a big push in the past 4 years with greatly improved performance and quality, especially around graphics.
• Next steps are focused on performance, stability, and maintainability, with new possibilities opening with Android and WebXR support.
• It's a pretty exciting moment for WebKit on Linux!