[alexandre-vl]

Refs zeronsh/zeron#540. Zeron's Linux browser uses this branch: zeronsh/zeron#1039 (it pins b564a34).

Zeron's Linux browser now renders pages with WPE WebKit in a helper process, into dma-bufs. To show those frames at the display's rate without CPU copies, GPUI needs three things:

1. Update a painted image in place.
2. Copy only the damaged regions of another process's dma-buf into it, on the GPU.
3. Keep calling back at the display's rate while the window is inactive.

The branch is stacked on 0dc69aa (zeron/drag-needs-held-button), the rev Zeron pins today, so this diff shows only the three commits below.

Commit	What
5526f55 Update atlas tiles in place, from pixels or imported dma-bufs	New atlas API and the Vulkan dma-buf import (Linux, FreeBSD)
5392ee1 Keep display-rate frame callbacks in inactive windows	Window::on_next_display_frame
b564a34 Wayland: keep frames coming after a present outside the frame loop	Bug fix: a forced draw could stop a window's frames for good

API

API	Where	Does
RenderImage::blank(size)	all	An image whose pixels only arrive through update_image
Window::insert_blank_image(image, frame)	all	Allocates its tile without uploading anything; returns whether the tile is new, its content undefined until filled
Window::update_image(image, frame, region, update, on_complete)	all; only gpui_wgpu updates in place, the others return Ok(false)	Overwrites region from CPU pixels (AtlasTileUpdate::Pixels) or from an imported dma-buf (AtlasTileUpdate::Dmabuf)
Window::dmabuf_target()	Linux, FreeBSD	The render node GPUI draws with, and the DRM modifiers it imports
Window::import_dmabuf(&Dmabuf) → DmabufImport	Linux, FreeBSD	Imports once; dropping it frees the image once no queued copy reads it
Window::on_next_display_frame(cb)	all	on_next_frame for content that follows the display: an inactive window, otherwise capped at ~30 fps, keeps the display's rate
PlatformAtlas::{insert_blank, update_tile, dmabuf_target, import_dmabuf}	trait, default impls	Metal and DirectX atlases compile unchanged

The update_tile contract

• on_complete runs exactly once, errors included, never with the atlas locked, and only after the GPU has finished all work queued before it. A producer can recycle a buffer from that callback.
• Updates land in the order they were queued, with one exception: pixels land before the frame's dma-buf copies and drop the copies they fully cover. A producer that switches from copies to pixels updates the whole tile.
• If the device is lost, the pending completions run and the imports are dropped; producers import again.

What is imported

• Format: AR24 (B8G8R8A8_UNORM), single plane.

• The device opens with VK_EXT_image_drm_format_modifier when the GPU has it, so tiled layouts import too. NVIDIA's EGL renders only to its tiled layouts.

• Only uncompressed modifiers are imported:

  Vendor	Accepted
  Intel	X, Y, Yf, 4 tiling
  AMD	no DCC (bit 13 clear)
  NVIDIA	compression bits 23–25 clear
  Vendor 0	LINEAR only
  Others	none

  wgpu moves an imported image out of UNDEFINED without acquiring it from the producer's queue, which lets a driver reinitialize compression metadata and lose the pixels.

• Before creating the image, the import checks each layout's importability and maximum extent (vkGetPhysicalDeviceImageFormatProperties2 with the modifier). It also checks the dma-buf is at least as large as the image's memory requirement, because an unsupported layout or size is undefined behavior, not an error.

• The image binds the buffer with an explicit plane layout (offset, stride) in dedicated memory. The duplicated fd is closed if allocation fails; on success, Vulkan owns it.

Measured in Zeron

zeronsh/zeron#1039 measured Zeron's browser with this branch: release builds, a 240 Hz display, a 2849×1956 px viewport, 3 runs per cell.

	Zeron main (WebKitGTK, CPU frames)	With this branch (WPE WebKit, dma-buf imports)
2D canvas / WebGL 2 / scrolling / CSS, frames shown per second	7 / 5 / 21 / 22	240 / 240 / 240 / 240
Display refreshes without a new frame	94%	0 of 23,029
CPU per frame shown, 2D canvas	191.9 ms	2.4 ms
Bytes uploaded CPU→GPU per frame	22.29 MB	0 (22.29 MB copied on the GPU)
Press → frame painted, p50	36.8 ms	7.6 ms

The same path runs on the Radeon 610M iGPU (RADV, modifier 0x0200000000401b03) and through Xwayland. The PR has the full tables.

Tests

New: update_tile_overwrites_only_the_region, update_tile_needs_a_cached_tile_inside_its_bounds, dmabuf_regions_copy_into_the_tile, dmabuf_imports_refuse_unsupported_layouts_and_sizes, only_uncompressed_layouts_are_imported, inactive_windows_slow_frame_callbacks_but_not_display_frames.

Suite (Linux 7.2.8, RTX 3080 driver 615.78.08 open, Mesa 26.2.5)	Result
cargo test --locked -p gpui --lib	229 passed
cargo test --locked -p gpui_wgpu --lib -- --include-ignored	35 passed (2 need a Vulkan adapter)
cargo test --locked -p gpui_linux --lib	24 passed
cargo check --locked -p gpui -p gpui_wgpu -p gpui_linux --tests on 5526f55 alone	ok

Not covered by tests:

• A pixel update that only partly covers a queued copy.
• clear() with copies pending.
• Completions after a real device loss.
• Windows and macOS: compile-only through the default trait impls (this repo's Windows CI job).

---

^{Need help on this PR? Tag @codesmith-bot with what you need.}