XDC 2025 - X.Org Developer's Conference

29 Sep 2025, 08:00 → 1 Oct 2025, 18:20 Europe/Vienna

Monday, 29 September

08:00 → 09:00 Breakfast and Registration

09:00 → 17:40 Main Track

09:00 Monday Opening Session

Speakers: Heinrich Fink (Snap Inc.) , Prof. Michael Wimmer (TU Wien)

09:15 Descriptors are Hard

One of the chief challenges in modern graphics drivers is accessing resources that live outside the shader. While shader compilation is largely a well-understood problem, the interface between the shader and the rest of the API is still a challenge. OpenGL and Vulkan, and D3D12 all have vastly different approaches to solving this problem. In this talk, Faith will give an overview of resource mapping, both from an API and a hardware perspective, and talk about some of the ways that Vulkan has advanced in recent years to try and make the situation better.

Speaker: Dr Faith Ekstrand (Collabora)

2025-09-29 - XDC 2025 - Descriptors are Hard.pdf

10:05 What’s new in ir3

ir3, the compiler backend for Adreno GPUs used by Freedreno and Turnip, has recently gained support for some interesting hardware features. From vectorized instructions to register aliasing, this talk will cover some of those features and the challenges we faced while implementing them. To lay the groundwork, I will also talk about the internals of ir3, and about the debugging and reverse engineering tools we have at our disposal to help us understand new hardware features.

Speaker: Job Noorman (Igalia S.L.)

ir3.pdf

10:30 Improvements to the Raspberry Pi driver stack

This talk will deliver an overview of the recent development efforts in the Raspberry Pi driver stack focusing on three areas: bugfixing and stability improvements, better performance and OpenGL 3.2 compliance.

The first part of the presentation will focus on new features to better align with OpenGL 3.2 requirements, namely seamless cubemaps, 16-bit normalized format suppport as well as other features such as robust context support and more.

The second part will focus on performance improvements. Here we will discuss the various improvements implemented in the GL driver and show a comparative analysis to illustrate the impact of the optimization work.

Speakers: Juan A. Suarez (Igalia, S.L.) , Ella Stanforth

Improvements to the Raspberry Pi driver stack

Improvements to the Raspberry Pi GPU driver stack.pdf

10:50 Break

11:25 Support for VM_BIND and sparse textures in Freedreno

Until recently, freedreno, the upstream kernel driver for Qualcomm Adreno GPUs, has been using the same legacy memory management paradigm as other upstream DRM drivers. While this worked well for the gallium/GL driver, it was a poor fit for Vulkan, where memory is managed explicitly by the user, resulting in unnecessary complexity and CPU overhead, and it couldn't handle the more sophisticated use-cases required by "sparse textures" that are used by some of the latest games. In order to fix this we embarked on a major project across the entire stack to rewrite the internals of the kernel driver to use the recently-upstreamed gpuvm subsystem, expose a completely new "VM_BIND" uAPI for managing memory, and take advantage of it in turnip, the upstream Vulkan driver. This then finally allowed us to implement sparse textures in turnip. In this talk we'll go over the challenges of retrofitting VM_BIND into a mature production driver and dealing with the quirks of sparse textures on Adreno.

Speakers: Connor Abbott (Valve) , Rob Clark (Google)

drm msm - VM_BIND.pdf

Support for VM_BIND and sparse textures in Freedreno (XDC 2025).pdf

12:15 GPU SVM in DRM / Xe

Heterogeneous Memory Management (HMM) has been part of the Linux kernel for some time, with prior GPU-focused implementations in AMDKFD, Nouveau, and OpenNV. However, integrating HMM correctly—ensuring proper API usage, race handling, and locking—is notoriously complex. This talk introduces GPU SVM, a new abstraction layer that streamlines interactions between HMM and the core memory management (MM) subsystem, offering a more accessible and safer API for DRM driver developers. We will walk through the design of GPU SVM, its initial deployment in the Xe driver, key challenges and learnings from the integration process, and discuss future directions for shared virtual memory support in the DRM ecosystem.

[1] https://www.kernel.org/doc/html/v5.0/vm/hmm.html

Speaker: Matthew Brost (Intel)

12:35 Lunch

14:05 Panthor: Status and future development

Present the current status of the Panthor driver, update on the features we are working on and what the plans are for the future with regards to Arm Mali GPUs.

Speakers: Liviu Dudau (Arm Ltd) , Florent Tomasin (Arm Ltd)

XDC 2025 final.pdf

14:55 Tyr: a new Rust GPU driver

This talk will cover the current state of Tyr, a new GPU kernel mode driver written in Rust for ARM Mali GPUs. We will discuss the status of the abstractions in the Rust-for-Linux ecosystem and lay out the roadmap to upstream the driver. We will touch upon its relationship to the current C implementation in the kernel (Panthor) and how we plan to have these two drivers co-exist for the foreseeable future.

Speaker: Daniel Almeida (Collabora)

15:20 Display Testing without hardware: discovering the power of VKMS!

As a userspace developer, creating graphical applications is a common
task. While software and frameworks like Weston or Qt make it
straightforward to display content on a screen, ensuring compatibility
across various displays poses significant challenges. Users may have
different screen sizes, resolutions, and capabilities, making
comprehensive testing complex. How will your application perform on a
small screen? What about an extremely large one? How does it react to
displays being connected/disconnected? Moreover, if your application
must run on diverse devices, how will it leverage or adapt to varying
hardware capabilities?

VKMS addresses these challenges by enabling graphic testing without
the need for physical hardware. VKMS is a Linux kernel DRM driver that
allows you to emulate a wide range of display configurations on any
device. This talk will introduce VKMS, highlight its current
capabilities, demonstrate practical test examples, and provide details
on additional features we are currently working on upstreaming into
VKMS.

Speaker: Louis Chauvet

vkms.pdf

15:30 Break

16:05 GPU Job Scheduling in DRM: Past, Present and Future

All GPU drivers need a load balancing mechanism for submitting jobs (i.e., command buffers) to their GPU. The shared infrastructure for this in the Linux kernel's DRM subsystem is the DRM GPU Scheduler. This component has accumulated a large number of problems over the course of a decade. The talk shall give an overview over the history of the scheduler and how the problems came to be. Moreover, it shows which problems were solved during the last 12 months, and which still persist. This part of the talk will also serve as an RFC for how we as kernel developers can work towards avoiding the most significant issues of the category the scheduler experienced.

Another important aspect of the GPU Scheduler that shall be highlighted is the addition of support for firmware scheduling: For GPUs whose firmware performs the actual scheduling (instead of the kernel being responsible for that), the DRM GPU Scheduler is not an actual scheduler anymore, but a mere load balancer. This motivates the introduction of a new, significantly simplified piece of DRM infrastructure: the DRM Jobqueue. The Jobqueue is intended to serve as a simpler, more robust replacement of the DRM GPU Scheduler. First intended users are upcoming drivers such as Nova, and, possibly, later also existing users of the GPU Scheduler.

Speaker: Philipp Stanner (Red Hat)

GPU Job Scheduling in DRM_ Past, Present and Future-2.pdf

16:30 Finally fixing Multi-GPU on Linux

Compositors have long relied on ignoring additional GPUs on a system as far as they can, while application configuration is left to users with obscure environment variables and config files.

We propose a new service with dynamic configuration and policies similar to what other OSes provide already and accompanying changes to desktop environments and compositors to finally allow deterministic and user-visible gpu selection.

Speakers: Victoria Brekenfeld (System76) , Sebastian Wick (Red Hat)

16:55 Addressing Mesa CI pain points: what we've done, and where we are going

Mesa CI has one of the most complex CI pipelines. While this is great for test coverage, this also brings challenges in infrastructure, usability, and sustainability. In this talk, we will present what we think works, what needs improvement, and what is currently on our roadmap.

We've submitted a workshop proposal to discuss these issues further and agree on the roadmap for the next 12 months. Come watch the talk and join the workshop to let us know if we've missed any pain point and influence these plans!

Speakers: Martin Roukala (né Peres) (MuPuF TMI / Valve contractor) , Eric Engestrom (Igalia / Mesa) , Sergi Blanch Torné (Collabora)

slides.pdf

17:20 Vulkan CTS Tips & Tricks

The Vulkan Conformance Test Suite contains millions of conformance tests to check Vulkan drivers implement the specification correctly. Most people working on Vulkan drivers and related projects will have to deal with it at some point. In this talk I will present an overview of the project and some of its internals, and will try to answer some practical questions such as:

• How to best interact with this Khronos project.
• How to report issues and what kind of issues are considered interesting.
• How to build the project faster.
• How to view result images easily.
• How to locate the source code of a particular test.
• How to find tests that use a given feature or extension.

Speaker: Ricardo Garcia (Igalia, S.L.)

cts-slides.pdf

09:15 → 12:10 Workshop, Meeting or Hacking Session

10:05 Workshop: Embedded Graphics Stack 101

Introductory workshop to the Linux embedded graphics stack, presented by Collabora Ltd. This is a great opportunity for students and professionals who are not familiar yet with this area, and who would like to learn more about how open source software drives high performance graphics across the industry, and how to contribute in these areas.

Planned Agenda:
- Brief introduction to the embedded open source graphics stack, using the open ARM Mali driver stack as a specific example (presentation, ca 30mins)
- Hands-on session demonstrating a practical example of manipulating the Mesa Vulkan driver stack to change the output of a simple graphics program on am ARM Mali development board.
- Q & A throughout the session about topics like Mesa, graphics programming, how to contribute to open source, professional work in open source graphics and related

If you bring a Linux laptop, we might even try to compile Mesa locally, too (if time permits)

Prerequisites (optional):
- Basic knowledge of a graphics API is useful (GL / Vulkan)
- Basic C programming (Mesa is written largely in C)
- If you have a Linux laptop, bring it with you

Speaker: Erik Faye-Lund (Collabora)

xdc2025-starting-drm.pdf

17:45 → 18:05 Lightning Talks

17:45 DisplayPort DRM framework

DisplayPort is a feature-rich display standard with plenty of features that are hard to get implemented in a correct and efficient way.
The DRM HDMI connector framework, recently added to the kernel, pointed out the necessity to get core parts of a similar standard implemented in the framework itself. This talk is focused on implementing the DisplayPort framework to be used by DRM drivers.

Speaker: Dmitry Baryshkov (Qualcomm Technologies Inc.)

XDC 2025 - DRM DP framework.pdf

17:50 NPU drivers: 2025 update

A quick update will be given on the two Mesa-based NPU drivers (Etnaviv and Rocket) and also on other two drivers that are in the planning phase as of May 2025. Also on plans for 2026.

Speaker: Tomeu Vizoso (Independent contractor)

XDC_2025_NPU_TV.pdf

17:55 A love song for gamers with old GPUs

Both RADV (the Mesa Vulkan driver for AMD GPUs) and AMDGPU (the Linux kernel driver for AMD GPUs) were started at a time when the first GCN GPUs were still relevant. That might make you think that GCN 1-2 and other GPUs from that era are working well with Linux by now, but the truth is... complicated.

This lightning talk will go over some of our recent efforts to improve support for GCN 1-2 era GPUs and present the current state of Linux user experience on these GPUs. I would also like to spark a conversation with the audience about opinions and expectations around old GPU support.

Speaker: Timur Kristóf (Valve)

xdc2025_old_gpus.pdf

18:30 → 21:30 Social Event: Welcome Reception, sponsored by Snap

https://maps.app.goo.gl/xWwxfCkipMYnRo5m9

Tuesday, 30 September

08:00 → 09:00 Breakfast and Registration

09:00 → 17:20 Main Track

09:00 Tuesday Opening Session

Speaker: Heinrich Fink (Snap Inc.)

09:15 Machine learning with NIR

Extensions to NIR that allow to express operations on tensors will be explained. New intrinsics will be introduced and there will be quick walkthroughs on how to optimize a NIR ML program with hardware-independent and hardware-specific passes. Machine code generation will be also quickly covered, both to GPGPU units and to fixed-function accelerator hardware.

Speakers: Tomeu Vizoso (Independent contractor) , Philipp Zabel (Pengutronix)

XDC_2025_NIR_NPU.pdf

10:05 A case study of core affinity for concurrent GPU workload execution on ARM Mali

XR compositors rely on timely execution of GPU workloads to apply a late-stage framebuffer update shortly before scanout. This operation often contends with other concurrent rendering workloads occupying the GPU, and its completion might get delayed past its deadline, resulting in undesired artefacts.

A widely used solution to this problem is to apply some form of GPU-level preemption. However, preemption latency still varies with the type of workload to preempt, a risk of excessive delays of the time-sensitive workload remains.

In this talk we discuss a different approach: provided we have multiple independent execution GPU cores available, can we reserve a core for the time-sensitive workload to execute independently of everything else? We present a brief case study using the ARM Mali G610 GPU, a four-core configuration, driven by the PanVK/panthor open-source Vulkan driver.

Speaker: Heinrich Fink (Snap Inc.)

XDC2025_A_case_study_of_core_affinity_for_concurrent_GPU_workload_execution_on_ARM_Mali_snap_hfink.pdf

10:30 An upstream-first approach to application virtualization

Spectrum is a Linux-based desktop operating system which aims to provide improved security by isolating each application running on the system (as well as drivers where possible) into its own lightweight virtual machine, while still providing a integrated desktop system. In contrast to previous virtualization-based desktop compartmentalization efforts, Spectrum takes an upstream-first approach, building on top of mechanisms like Wayland security contexts, XDG Desktop Portals, and virtio-gpu. This talk is an overview of how various freedesktop.org interfaces, including those which were not designed with virtualization in mind, can be used to enable a much more cohesive and sustainable compartmentalized system than has been possible in the past, and aims to start a discussion about how virtualization might be further accommodated in freedesktop.org protocols and implementations going forward.

Speaker: Alyssa Ross

An Upstream-first Approach to Application Virtualization.odp

10:50 Break

11:25 Wayback: a compatibility layer for X11 desktops

Wayback is a new project which aims to provide an alternative to the X.org server and DDX drivers using Wayland components instead. This talk will include a review of current progress, a discussion of the overall roadmap and a demo of wayback’s capabilities at the time of the talk.

Speaker: Ariadne Conill

wayback-xdc2025.pdf

12:15 A Vulkan renderer for Weston

New Mesa drivers are starting to default to Vulkan-first (with OpenGL provided as a layer by Zink). One important part of enabling a new Vulkan driver is to enable WSI (Window System Integration) and support compositors through e.g. Wayland. The options to support this WSI development for new Vulkan-first drivers haven't been too many or require significant enablement upfront, so these platforms may significantly delay being able to run a first Wayland compositor which can run some simple Vulkan applications on a display.
The Weston Wayland compositor has been used for this purpose during enablement of OpenGL drivers and has useful features/backends to support that, it would be great if Weston had a native Vulkan renderer with that use case in mind.
Well, now it does! https://gitlab.freedesktop.org/wayland/weston/-/merge_requests/1679

This talk aims to introduce the state and design choices of the Weston Vulkan renderer, bring up some of the current challenges, and start a discussion on its applications (Vulkan-first platforms, development, testing and CI for Vulkan drivers, actually using it as a compositor, etc).

Speaker: Erico Nunes

XDC 2025 - A Vulkan Renderer for Weston.pdf

12:35 Lunch

14:05 Content Protection on Linux: Challenges, Architectures, and Evolving Standards

With the rapid proliferation of high-quality digital media, effective content protection mechanisms have become essential to prevent unauthorized copying, redistribution, and piracy. This presentation explores the architecture and implementation of content protection (CP) technologies in the Linux graphics stack, focusing primarily on High-bandwidth Digital Content Protection (HDCP) and Protected Audio Video Path (PAVP).
We begin by examining the motivations behind content protection: protecting creators’ intellectual property and meeting stringent compliance requirements imposed by content providers and licensing authorities. The talk outlines the historical limitations of HDCP 1.x—its reliance on aging cryptographic algorithms such as RC4, limited interface support, and vulnerability to reverse engineering—and describes how HDCP 2.x addresses these shortcomings through modern encryption (RSA, AES), enhanced revocation mechanisms, and expanded compatibility with newer interfaces like HDMI 2.0, DisplayPort, and USB Type-C.
The presentation then details how content protection flows from userspace to the kernel driver. We cover how userspace software negotiates and sets content protection properties (CONTENT_PROTECTION and CONTENT_TYPE) via DRM/KMS APIs, and how kernel drivers enforce these policies, maintain state transitions, and ensure authenticated link establishment between the GPU and display sink. Special emphasis is placed on how HDCP is typically used only for external displays, while PAVP provides hardware-protected sessions internally and can be sufficient for trusted embedded panels.
Attendees will gain insight into the specific driver responsibilities—such as signaling userspace when protection states change—and the integration of HDCP and PAVP to achieve a secure end-to-end content pipeline. The session will also discuss the practical challenges and trade-offs associated with implementing CP, including usability, latency, power consumption, and the complexity of supporting multiple evolving standards in an open-source environment.
The presentation aims to provide developers, driver maintainers, and architects with a clear understanding of the current state of content protection on Linux, the reasons behind specific design choices, and the practical considerations when enabling CP in production systems.

Speaker: Suraj Kandpal (Intel)

14:55 KosmicKrisp, a Vulkan to Metal layered driver

This talk will introduce the KosmicKrisp Vulkan to Metal driver LunarG has been creating. We will discuss why the driver was created, and how the Mesa Vulkan driver framework enabled a fast, Vulkan conformant implementation.

Speaker: Aitor Camacho Larrondo (LunarG)

15:20 Demo: KosmicKrisp, a Vulkan to Metal layered driver

This demo will showcase the KosmicKrisp Vulkan to Metal driver LunarG has been creating.

Speaker: Aitor Camacho Larrondo (LunarG)

15:30 Break

16:05 The Power of Video

For the past two years, there has been some great work done across display components to optimize power consumption for video playback. This talk will highlight some of this work using Firefox/MPV, Weston, and amdgpu as an example. The goal is to demonstrate real power savings, and to show what can be done today to improve video playback power.

Speaker: Leo Li (AMD)

slides_the-power-of-video.pdf

16:30 Adding New YUV Formats to Mesa

There are a plethora of YUV formats found in the wild, and it seems
like more are added every day. Adding a new format to Mesa requires
several steps that may not always be obvious. In this talk we'll
discuss how to add support for a new YUV texture format to OpenGL,
and some of the recent infrastructure work that should make this easier.

Our focus is on OpenGL and EGL, but if time permits we'll briefly discuss
how things change for Vulkan.

Speaker: Eric Smith (Collabora, Ltd.)

XDC_yuv_talk.pdf

16:55 Remarks on 2D Hardware Acceleration Support

Numerous chips still come with dedicated 2D hardware accelerators that are often not part of bigger gpu unit. These devices are usually very efficient for simple compositing and transform works and can be useful to accelerate display compositing or be used as part of multimedia pipelines. They also typically offer low latencies and low power cost.

Unfortunately they are mostly unsupported in Linux and there is no standard userspace API and implementation to leverage them. As of today, most users looking to use these units are left with proprietary APIs and binary libraries.

This talk will present a brief overview of 2d acceleration hardware, exisiting proprietary APIs and the current state of things in mainline Linux. Some thoughts and propositions to properly support these units will then be discussed.

Speaker: Paul Kocialkowski (sys-base)

remarks-2d-hardware-acceleration-support.pdf

09:15 → 10:50 Workshop, Meeting or Hacking Session: Workshop, Meeting or Hacking session

09:15 Workshop: Mesa CI - What still needs to be done, and how to get there?

The Mesa CI is complex and has many issues that are being addressed (see presentation "Addressing Mesa CI pain points: what we've done, and where we are going").

This workshop will be dedicated to discussing outstanding pain points from the presentation, so that we (the CI developers) can make sure you (the CI users = Mesa developers) agree on what these pain points are, and what our plan to address them should be.

The currently known pain points are:
- Reliability of the Marge workflow (unavailable runners, flaky jobs, ...)
- Long waiting times to get your MR tested and landed
- Requirement to use an external script (GitLab web UI missing some buttons to run just the jobs we want).
- Reproducing CI jobs locally.
- Updating job expectations (collating results from multiple runs, reducing the size of the flakes lists, failure rate of different tests, ...)
- GPU hangs: how to prevent merging code that sometimes hang the GPU, and how to minimize impact of flaky hangs once the regression is merged
- Keeping track of pain points and their current state (new issue tag?)
- And probably more, so come tell us what is your pain point!

Speakers: Eric Engestrom (Igalia / Mesa) , Martin Roukala (né Peres) (MuPuF TMI / Valve contractor) , Sergi Blanch Torné (Collabora)

11:25 → 12:35 Workshop, Meeting or Hacking Session

11:25 Workshop: GPU recovery

Unexpected errors can sometimes occur at the GPU driver level, so the GPU must be capable of recovering from these problems in a way that minimizes disruption to the user experience. GPU recovery is a complex topic that becomes even more challenging when considering the specific characteristics of vendor hardware. Additionally, it is necessary to establish some level of interoperability between the kernel and userspace; ideally, both sides should work together to enhance the user experience.

In this context, this workshop is dedicated to discussing GPU recovery from kernel space to user space (and vice versa). With these ideas in mind, we aim to cover some topics such as:
- Per-component reset.
- User Queues Vs. Kernel Queues.
- Enforce Isolation.
- Trap handlers.

There are multiple patches around this topic floating on the mailing list, for example:

• https://lore.kernel.org/dri-devel/20230929092509.42042-1-andrealmeid@igalia.com/
• https://lore.kernel.org/dri-devel/20250204070528.1919158-1-raag.jadav@intel.com/
• https://lore.kernel.org/amd-gfx/20250701184451.11868-1-alexander.deucher@amd.com/T/#t

If you are interested in discussing some of the topics mentioned above, please join us for this workshop.

Speaker: Rodrigo Siqueira Jordao (Igalia)

17:20 → 18:15 Lightning Talks

17:25 Improving buffer and image copies on Turnip

Adreno GPUs have a 2D engine which can be used for most buffer and image copies, so operations like vkCmdCopyBuffer(), vkCmdCopyBufferToImage(), vkCmdCopyImage(), and vkCmdCopyImageToBuffer().

With the introduction of the Adreno A750 GPU, a new feature was added to the 2D engine allowing for faster copy operations. However it does come with some restrictions that we’ve had to discover through trial and error.

We’ve also gained understanding of a specific register bit, available even on A6XX GPUs, allowing us to improve copy performance of float 16 formats.

To measure the performance impact, we developed a Crucible benchmark. Results showed an improvement of 70% and over for a whole lot of formats.

Speaker: Karmjit Mahil (Igalia S.L.)

Improving buffer and image copies on Turnip.pdf

17:30 Improving the current state of the DRM in-kernel client ecosystem

DRM drivers implement different APIs to drive in-kernel applications such as framebuffer console support and drm_panic. More in-kernel applications, like bootsplash, will be in the kernel before we know it.

Many DRM drivers implement DRM framebuffer console support while only a few support drm_panic. Adding more in-kernel applications with separate driver APIs will lead to few initial driver adopters. This talk will explore how the driver-side API can be unified and build upon previous attempts at doing so.

Speaker: Rahul Rameshbabu (NVIDIA Corporation)

XDC_2025_DRM_in_kernel_clients.pptx.pdf

17:35 Screencasting on Wayland: Evolution and Challenges

The migration from X11 to Wayland has fundamentally transformed how everyday operations work under the hood, introducing new challenges that required innovative solutions. Screencasting is one such challenge that needed complete reinvention.

Leveraging the hands-on experience we gained at NVIDIA, this talk will examine screencasting on Wayland from both compositor and client perspectives, with a focus on performance and usability. We'll explore the existing approaches to screencasting, discuss the state of explicit synchronization in screencasting for achieving high-performance, frame-accurate capture, identify the pain points that we ran into and outline what remains to be done to advance screen capturing in the Wayland ecosystem from our point of view.

Speaker: Doğukan Korkmaztürk (NVIDIA)

Screencasting on Wayland.pdf

17:40 An update on drm_hwcomposer

drm_hwcomposer implements Android's Hardware Composer HAL on top of the drm uAPI. While the project has been around for several years, this talk will highlight some of the recent developments in the project and touch on what we'd like to do next.

Speaker: Drew Davenport (Google)

XDC 2025 - An update on drm_hwcomposer.pdf

17:45 DRM Panic: The BSOD is coming to Linux

DRM Panic faces the challenging task of informing users about a kernel crash.
This presentation will cover the current implementation, the compromises made during its development, and provide guidance on adding DRM Panic support for your preferred GPU.
Finally, we will demonstrate how the panic screen can be configured and customized. We will also show how its QR code feature can assist in debugging kernel crashes.

Speaker: Mr Jocelyn Falempe (Red Hat)

drm_panic.pdf

17:50 Introducing wltest - automating wayland client & driver testing

As Wayland increasingly becomes the default in distro releases, one issue frequently encountered is how to handle automated testing. This talk introduces "wltest", a small open source test suite written in Rust that we have started building at NVIDIA to better support automated Wayland testing with our driver CI systems. wltest runs as a regular desktop client and does not require custom builds or headless test setups. We will discuss the challenges of client automation on Wayland, how wltest can help the community, driver bugs wltest has found, and what the future of Wayland testing could look like with community collaboration.

Speaker: Austin Shafer (NVIDIA)

Wltest - XDC 2025.pdf

Wltest - XDC 2025.pptx

17:55 Cooperative Matrix in NVK

Mary started to implement cooperative Matrix support in NVK/NAK and I finished it and added some performance optimizations. We want to go over some of the details and highlight some Nvidia specific things in there.

Speaker: Karol Herbst (Red Hat, Nouveau)

main.pdf

18:20 → 18:50 X.Org Board of Directors Meeting

Speaker: Mark Filion (Collabora)

Wednesday, 1 October

08:00 → 09:00 Breakfast and Registration

09:00 → 17:20 Main Track

09:00 Wednesday Opening Session

Speaker: Heinrich Fink (Snap Inc.)

09:15 Turnip: Improving performance without compromising correctness

Turnip is a Vulkan driver for Adreno GPUs, written by reverse engineering the hardware. We also don’t yet have many real-world users running games, but the driver is capable of running games that use D3D12, VK, D3D11, and older APIs. In such an environment, maintaining driver correctness while delivering performance improvements is a challenge.

At previous XDCs, I talked about how to debug GPU issues and how to improve the GPU debugging experience; however, the best way to do that is to avoid debugging issues altogether. Catching them early, when changes are being written, is much more productive.

I will talk about:
- Using single frame game captures in CI to test correctness;
- Detecting performance regressions with the same CI runs;
- Making detailed performance comparisons against the closed-source driver.

Speaker: Danylo Piliaiev (Igalia S.L.)

10:05 PanVK: from PoC to Vulkan 1.4 in less than a year

PanVK has been improving quickly over the last year. This talk will go through the current status of PanVK, what happened over the last year, the challenges we've encountered along the road, and what tasks lays ahead!

Speakers: Erik Faye-Lund (Collabora) , Lars-Ivar Simonsen (Arm Ltd)

xdc2025-panfrost.pdf

10:30 Adapting etnaviv to contemporary Vivante hardware

The etnaviv driver is beginning to support the latest features added to the newer GPU generations of Vivante hardware. This talk will present the challenges that we’re facing in adapting the driver and how we’ve improved the CI system notably to make these changes possible. A significant focus will be on our strides towards full GLES3 support: what’s landed, what’s in progress, and what’s next. Attendees will leave with a clear picture of etnaviv’s current state, roadmap, and how they can get involved or benefit from ongoing work.

Speaker: Christian Gmeiner (Igalia)

adapting_etnaviv_to_contemporary_vivante_hardware.pdf

10:50 Break

11:25 RADV: Are we there yet?

RADV is the Mesa Vulkan driver for AMD GPUs. It started in 2016 as an experiment for GCN 1. Now RADV supports the very latest GPUs and offers cutting-edge features such as ray tracing, mesh shading, DGC and more. We spearheaded a custom compiler backend called ACO. Thanks to the ubiquity of Vulkan on the Linux desktop, today RADV is the most widely used open source Vulkan driver for gaming.

After so many years of development, it's time to ask, are we there yet?

This talk presents the current direction of RADV development, as well as some of the experience we gained on the way. It's also a status update on what's been happening in RADV over the past couple of years.

I'll show the latest developments, how we maintain the code, how we are endeavouring to share code with RadeonSI, how we use NIR to improve our compiler stack and how we've retire thousands of lines of legacy code from both drivers. I'll also touch on the topics we're currently working on and the issues we still face.

Speakers: Timur Kristóf (Valve) , Daniel Schürmann (Valve)

xdc2025_radv_are_we_there_yet.pdf

12:15 Nouveau/NVK Update

A lot has happened in Nouveau in the last year, including Vulkan 1.4 support in NVK; Vulkan conformance on Maxwell, Pascal, Volta, and Kepler; and the switch to Zink for OpenGL. Faith will talk about the advances made in NVK in the last year as well as plans going forward.

Speaker: Dr Faith Ekstrand (Collabora)

2025-09-29 - XDC 2025 - Nouveau NVK Update.pdf

12:35 Lunch

14:05 KMS offloading in KWin

I'll give an overview of how KDE's compositor uses KMS offloading for improved efficiency and performance - including overlay planes, underlays and color operations - and what problems we've faced when trying to use more of these KMS features.

Speaker: Xaver Hugl (Blue Systems)

XDC2025.pdf

14:55 MSM display and graphics update

MSM display and graphics drivers (both kernel and user space) continue to evolve over the years both in terms of feature set , chipsets supported and also complexity.

This talk focuses on the new features gained by the drivers (new chipsets, improved resource allocation for display planes, VM_BIND, RustiCL support) and on lessons learned during this development.

Speakers: Dmitry Baryshkov (Qualcomm Technologies Inc.) , Rob Clark (Google)

drm msm - status report.pdf

15:20 Display Engine Based Adaptive Sharpness Filter

In this talk, we will present an adaptive sharpness filter implemented in the Intel graphics display engine [1], designed to intelligently enhance image clarity based on content characteristics. Unlike conventional sharpening techniques that apply uniform enhancement, our solution preserves visual quality by adapting dynamically to scene details, with minimal power and performance overhead.
We will begin with the motivation behind introducing this feature in the display engine, followed by a deep dive into the kernel-level implementation and its architectural considerations. Next, we will discuss the validation methodology, including our use of the IGT GPU Tools framework and Chamelium-based testing [4] to ensure correctness and robustness. Finally, we will explore the current state of userspace integration efforts in open-source compositors such as GNOME [2] and KDE (KWin) [3].
As part of the upstream journey, we are currently facing two main challenges: acceptance of the proposed UAPI and gaining support for the feature at the compositor level. This session aims to open up discussion around these issues and encourage collaboration. The implementation is available in open source, and we welcome contributions from the broader community to help drive this forward.

[1] KMD: https://patchwork.freedesktop.org/series/138754/
[2] Mutter: https://gitlab.gnome.org/GNOME/mutter/-/merge_requests/3665
[3] Plasma: https://invent.kde.org/plasma/kwin/-/merge_requests/7689
[4] IGT: https://patchwork.freedesktop.org/series/130218/

Speakers: Ms Swati Sharma, Ms Nemesa Garg, Mr Adarsh GM

15:30 Break

16:05 Driving multiple display outputs from single display pipeline using Superbuffer composition

Now a days many consumer electronics segments demand several display outputs coming out of a single Graphics card. Like modern Automotive infotainment segment demands 12-15 HDMI display outputs being driven from a single GPU, so that they can be used to display navigation panel, control panel, mirrors, multiple media players and several independent status readers to show speedometer, maps, odometers, temperature, music etc. But due to limited number (3-4) of display pipelines available in its Display engine, the GPU can only drive 3 or 4 independent output displays per card, which leaves a gap for a solution in this market.

The method proposeed here presents a unique method combining the synergy of SW and HW to solve this problem. The software creates graphics superbuffers to encode multiple display outputs in a single large framebuffer, and drives it in a single display pipeline by using GPU's capacity to drive high resolutions and then uses a smart splitter HW at the end of the display pipeline to splits and push these splitted buffers into multiple display outputs.

If implemented precisely, this method will allow a single GPU to drive 12-16 output displays.

Speaker: Shashank Sharma

16:30 Display Next Hackfest Update

In early July AMD is hosting a Display Next Hackfest where compositor and driver developers come together to discuss features and pain points and work toward solutions across the stack, including compositors, wayland protocols, DRM/KMS interfaces, and kernel drivers. Previous year's Hackfests have been hosted by Red Hat and Igalia.

Proposed topics can be found at https://github.com/hwentland/2025linuxdisplayhackfest/wiki/Topics-&-Talks

I will attempt to summarize the key discussions/outcomes from the Hackfest, touching on Color Management and HDR, Commit Failure Feedback, Real-Time Scheduling, and possibly more, depending on time.

Speaker: Harry Wentland (AMD)

2025 XDC Hackfest Update v1.2.pdf

16:55 State of the X.Org Foundation

State of the X.Org Foundation

Speaker: Lyude Paul (Red Hat)

09:15 → 10:50 Workshop, Meeting or Hacking Session

09:15 Hacking session: DisplayPort DRM framework

This hacking session is dedicated to identifying the parts of the DisplayPort standard that should be handled by the DRM framework and discussing possible implementations.

Speaker: Dmitry Baryshkov (Qualcomm Technologies Inc.)

14:05 → 15:30 Workshop, Meeting or Hacking Session

14:05 Workshop: DRM GPU Scheduler

This workshop is a meeting for all developers and users (and, of course, in general interested people) of the DRM GPU Scheduler. It is planned as a general brainstorming session to share ideas, plans and goals for the scheduler. Notably, the workshop shall serve to discuss problems in the domain of shared infrastructure in DRM, which has to satisfy quite different hardware vendors while simultaneously generalizing a solution for complex events such as GPU resets.

Speaker: Philipp Stanner (Red Hat)

17:20 → 18:20 Lightning Talks

17:20 Updates of VirtIO GPU support on Xen

Last two years of XDC, we introduce interim pinning buffer method for blob memory on Xen that's to enable virtio native context solution on Xen hypervisor, and ROCm support on virtio-gpu for compute machine learning applications. However, it's still not enough for automotive use scenario. So we introduce more advanced features like dynamic address mapping instead of pinning buffer which is specific on Xen for blob memory as formal solution, adding pps producer on amdgpu and renderstage with radv for perfetto to monitor GPU performance counter and trace events, GPU recovery virtualization mechanism to add robust context in weston compositor and qemu for virtio-gpu, and multiple contexts support on AMD KFD for ROCm native context to resolve one context per one process manner that can support multi-process in ROCm at guest VM, etc. In this talk, Ray will continue giving the introduction for latest GPU Para-Virtualization updates and future work on Xen.

Speaker: Ray Huang (AMD)

updates_gpu_paravirt_xdc2025.pdf

17:25 Putting the CL in VulCLan

Putting the CL in VulCLan

Speaker: Alyssa Rosenzweig

PuttingTheCLInVulclan.pdf

17:30 Rusticl status update

Going over new features added to Rusticl and will highlight a few of them (e.g Shared Virtual Memory). Also what's in the pipeline and will be coming.

Speaker: Karol Herbst (Red Hat, Nouveau)

main.pdf

17:35 Training an AI model for Compositor's Color corrections methods

In a typical Linux GUI system, a GUI application creates an application buffer and renders pixels on it. This application buffer can have multiple properties related to the color specifications of the buffer. Each application sends this app buffer to the graphics compositor SW. The compositor SW accepts these app buffers from various applications, composes a result framebuffer which contains pixels from all the app buffers and sends this result framebuffer to display driver to be shown on the connected Display sink.

Now, in order to compose/blend the resulting buffer correctly and accurately from the app-buffers, the color property specifications of each of the app-buffers need to be the same, which means, for example:
o the color space of all the app-buffers must be the same as target resulting framebuffer
o the color format of all the app-buffers must be the same as target resulting framebuffer
o the output colour tone of all the app-buffers must be the same as target resulting framebuffer (HDR or SDR)

All the app buffers which do not match the specifications need to be transformed before the composition blending process can take place. These transformations are jointly called “colour-correction” of a buffer.

This method proposes training an AI model for these color transformation, so that it can predict and suggest the most optimized color transformations for a typical composition scenario.

Speaker: Shashank Sharma

AI-model-for-Color-composition.pdf

17:40 Userspace virtual terminal in 2025

In 2014, an initiative emerged to supplant the kernel's graphical console, fbcon, with a userspace alternative named Kmscon. Despite this effort, and fbcon's subsequent loss of scrolling support due to a CVE, most Linux distributions continue to default to fbcon in 2025.

This presentation will explore various alternatives designed to enhance the user experience beyond what fbcon currently offers. These include:

• Kmscon: A minimalist userspace solution that remains actively maintained.
• Userspacevt: A collection of scripts enabling the use of a Wayland compositor and a graphical terminal to replace fbcon. I have packaged several combinations for Fedora, such as Cage/Foot, Gnome-kiosk/Ptyxis, and Kwin/Konsole.
• DRM Log: A kernel module leveraging the DRM infrastructure to display early kernel boot logs.

Speaker: Jocelyn Falempe (Red Hat)

userspace_vt.pdf

17:45 Surfaces for a Dock

In order to build an Application Dock as a separate Wayland client process, the compositor needs a way to share surfaces to that client, eg. as a miniaturized application window, an icon, or similar.

This talk will outline the use-case, present a currently working prototype, and intends to poll for further interest and if or how a proper solution could be shaped

Speaker: Philipp Kaeser (Google)

Surfaces for a Dock - Philipp Kaeser.pdf

17:50 Update on Imagination’s PowerVR Mesa effort

Update on Imagination’s PowerVR Mesa effort

Speakers: Frank Binns (Imagination Technologies) , Erik Faye-Lund (Collabora) , Ella Stanforth

XDC 2025 PowerVR Lightening Talk.pdf

17:55 Workshop recap: GPU recovery

A summary of topics discussed at the GPU recovery workshop.

Speaker: Rodrigo Siqueira Jordao (AMD)

GPU Recovery-lightning-talk.pdf

18:00 Workshop recap: DisplayPort DRM framework

Workshop recap: DisplayPort DRM framework

Speaker: Dmitry Baryshkov (Qualcomm Technologies Inc.)

XDC 2025 - DisplayPort Framework Takeaway.pdf

18:05 Workshop recap: DRM GPU Scheduler

Workshop recap: DRM GPU Scheduler

Speaker: Philipp Stanner (Red Hat)

DRM GPU Scheduler Workshop Summary-1.pdf