Firefox on Linux in 2025: The Path to HDR and Asynchronous Rendering

The evolution of Firefox on Linux represents a quiet but profound engineering narrative. For years, the platform's rendering stack lagged behind its Windows and macOS counterparts, constrained by the limitations of X11 and the nascent state of Wayland. Now, in 2025, we witness a maturation phase where Firefox is not merely catching up but pioneering advanced rendering techniques that leverage the unique capabilities of the modern Linux graphics stack. This progress is not accidental; it is the direct result of targeted collaboration between Mozilla engineers, compositor developers, and hardware vendors, culminating in three landmark achievements: HDR video playback, robust fractional scaling, and a complete overhaul to asynchronous rendering.

The most visually striking advancement is High Dynamic Range (HDR) support, tracked under Bug 1642854. While disabled by default, it can be enabled via the gfx.wayland.hdr preference in about:config. This feature fundamentally changes Firefox's rendering architecture on Wayland, adopting a model similar to Windows and macOS. Instead of rendering the entire application as a single surface, Firefox now composites its window from multiple subsurfaces. This layered approach is critical for HDR, as it allows video frames—encoded in the BT.2020 color space with PQ transfer function—to be sent directly to the compositor as subsurfaces, while the rest of the application (browser controls, HTML content) remains in Standard Dynamic Range (SDR). This design enables power-efficient, zero-copy playback, especially in fullscreen mode, where decoded video frames on the GPU are passed directly to the screen with minimal overhead, akin to dedicated media players like mpv. The implementation, initially spearheaded by Robert Mader and later unified into a new WaylandSurface object by Mozilla's Martin Stransky, utilizes the color-management-v1 protocol and requires 10-bit color vectors, necessitating hardware VP9 version 2 decoding. Feedback from AMD engineers led to optimizations like removing unnecessary texture creation and implementing wl_buffer recycling. While the core HDR rendering is complete, challenges remain, particularly with rendering scaled HDR content, which awaits the fractional-scale-v2 protocol.

Complementing HDR is the work on fractional scaling, which shipped in Firefox 147.0. Fractional scaling (e.g., 125%, 150%) has long been a pain point on Linux, often resulting in blurry text and UI elements due to improper rounding and scaling algorithms. The Firefox team addressed this by reworking the widget sizing code to strictly upscale window and surface sizes, avoiding the rounding errors inherent in downscaling. A significant hurdle was the lack of a defined rounding standard for Wayland subsurfaces. The solution involved implementing "Stable rounding" (as used by Mutter and Sway) for those compositors, while maintaining a different implementation for KWin. This ensures crisp, clear output across different desktop environments. The long-term goal is to adopt the fractional-scale-v2 protocol once it becomes widely available, which will standardize this behavior and simplify the codebase.

Perhaps the most architecturally significant change is the move to asynchronous rendering, addressed in Firefox 149.0. Historically, Firefox's Wayland pipeline was fraught with synchronization issues. The compositor would delete surfaces when windows were hidden or submitted with mismatched sizes, leading to protocol errors and crashes. The new pipeline, detailed in Bug 1739232, decouples rendering from window visibility. The key innovation is creating the rendering wl_surface, wl_buffer, and EGLWindow immediately upon window creation, before the window is shown. This allows painting to occur offscreen. When the window becomes visible, the surface is simply attached as a subsurface; when hidden, the attachment is removed. This preserves the backbuffer and eliminates the need for synchronized calls between threads, mirroring the efficient rendering models on Windows and macOS. The shift from fixed-scale buffers to the wp_viewport protocol further stabilizes the system, producing blurred output instead of crashes when scales don't match. The result is faster window operations and a more robust, modern rendering foundation.

These core advancements are supported by a suite of smaller but vital improvements. Audio playback now correctly prevents system sleep while the screen can dim, enhancing user experience. Asynchronous Wayland object management ensures clean removal without pending callbacks, boosting stability. Looking ahead, the Firefox Linux team faces a new set of challenges: implementing session-restore-v1 to correctly position windows across workspaces, developing a custom drag-and-drop handler to bypass GTK3 limitations, and integrating Vulkan video support via FFmpeg for NVIDIA hardware decoding. The journey is ongoing, but the current state of Firefox on Linux is a testament to focused, collaborative engineering that transforms a once-lagging platform into a showcase for cutting-edge graphics technology.

The rendering pipeline for HDR video, for instance, involves a complex dance between the browser, the graphics driver, and the compositor. When a video frame is decoded, it can be stored in a GPU buffer. In the new architecture, this buffer is passed directly to the Wayland compositor as a subsurface, avoiding a costly copy to system memory. This is the essence of zero-copy playback. The compositor, such as Mutter or KWin, then blends this HDR subsurface with the SDR subsurfaces of the browser chrome, applying the necessary color transformations. This layered approach is made possible by the Wayland protocol's flexibility, but it also introduces complexity. Managing the lifecycle of these subsurfaces—creating, mapping, unmapping, and recycling buffers—requires meticulous handling to avoid protocol violations and memory leaks. The Firefox team's work on asynchronous rendering directly addresses this by ensuring that the underlying surfaces are always in a valid state, regardless of the window's visibility.

The implications extend beyond mere feature parity. By embracing these advanced rendering techniques, Firefox is positioning itself as a first-class citizen on the Linux desktop, capable of leveraging the full potential of modern hardware. HDR support is no longer a Windows or macOS exclusive; Linux users can now experience richer, more vibrant video content. Fractional scaling ensures that high-DPI displays are usable and aesthetically pleasing, a critical factor for professional and creative workflows. The asynchronous rendering model not only improves performance but also enhances stability, reducing the crashes and glitches that plagued earlier implementations. This progress is a direct reflection of the health of the broader Linux graphics ecosystem. The advances in Mutter, KWin, and the Wayland protocol itself have created a fertile ground for applications like Firefox to innovate. It's a symbiotic relationship: as compositors mature, they enable new application features, which in turn drive further compositor development.

Of course, challenges persist. The reliance on emerging protocols like fractional-scale-v2 means that full functionality is still on the horizon. The need to test composited rendering for regular web pages to ensure it doesn't drain battery life is an ongoing concern. The complexity of layered rendering, with its rapid surface mapping and buffer switching, is a fertile ground for subtle bugs. Yet, the direction is clear. The Firefox team is methodically deconstructing the monolithic rendering pipeline of the past and rebuilding it as a flexible, asynchronous, and protocol-aware system. This is not a superficial update; it is a foundational shift that will serve as the basis for future innovations, from more efficient web games to complex web-based design tools.

For users and developers, this evolution offers both immediate benefits and a glimpse into the future. Enabling HDR in about:config today provides a tangible improvement in video playback. Running Firefox on a fractional scaling display now yields sharp, legible text. The performance gains from asynchronous rendering are noticeable in daily use, with snappier window operations. More importantly, this work demonstrates that the Linux desktop, once considered a second-class platform for high-end graphics, is now a viable and competitive environment. The collaboration between Mozilla, AMD, and the Wayland community is a model for open-source development, where shared goals and technical expertise converge to solve complex problems. As the team looks to the future—tackling drag-and-drop, Vulkan video, and session management—the foundation they have built in 2025 ensures that Firefox will continue to evolve in lockstep with the Linux graphics stack, delivering a powerful, stable, and visually rich experience for all users.