What Is Intel DRM Fabric? A Deep Dive into Linux GPU Interconnects & New Topologies

Have you ever wondered how Linux handles complex GPU and AI accelerator connections behind the scenes? With the rapid growth of high-performance computing and AI workloads, the need for smarter, more flexible hardware interconnects has never been greater. Enter Intel DRM Fabric—a cutting-edge proposal to revolutionize how Linux manages the intricate web of inter-device connections for GPUs and AI accelerators.

This article unpacks Intel’s DRM Fabric proposal in simple terms and exhaustive detail. We’ll journey from the foundational Linux graphics stack (the DRM subsystem and friends) to the nuts and bolts of the new fabric-endpoint-port-peer model, exploring its motivations, technical design, how it’s different from legacy approaches, why it matters for the future of AI, and how it fits into the wider world of Linux kernel development.

Background: The Linux DRM Subsystem and GPU Topology Challenges

The Direct Rendering Manager (DRM) is a distinguished subsystem of the Linux kernel. Its main job is to orchestrate the communication between the operating system and today’s graphics processing units (GPUs)—responsible for everything from your monitor’s basic output to complex 3D rendering and GPGPU computations.

As the technical center for GPU hardware management, DRM exposes a userspace API that allows programs to directly interact with GPU resources, set display modes, manage framebuffers, and handle advanced tasks like GPGPU compute operations. Over its evolution, DRM has expanded well beyond its roots as a support act for the XFree86 and X.Org display servers, evolving to support multi-head systems, GPU offloading (PRIME), seamless memory sharing, and many forms of buffer synchronization and device discovery.

But as clusters get larger and data-hungry tasks like AI and deep learning push hardware to the limit, the scale and complexity of inter-device connections have ballooned. Modern data centers might have racks of nodes packing multiple GPUs and accelerators, all needing to collaborate in ways that were unimaginable only a decade ago. In this environment, the limits of older, rigid interconnect architecture are plain to see—especially for evolving AI and HPC needs.

The Dawn of Interconnect Topology: Why We Need More Than Just Individual Device Support

At its core, GPU interconnect topology is all about how various compute devices—discrete GPUs, embedded accelerators, AI ASICs—are wired together to share data, workloads, and memory. This can mean direct PCIe links, high-speed NVLink lanes, or vendor-specific solutions like AMD’s xGMI and UALink.

Traditional DRM and Linux approaches generally treat each GPU as its own world, with limited understanding or representation of the bigger hardware network. Discovery, programming, and topology awareness are mostly delegated to vendor drivers, which often come with their own quirks, blind spots, and assumptions.

As the number of compute devices and vendors aiming to talk to each other scales up, friction appears:

• No standardized, vendor-neutral topology modeling—each company’s driver “knows” only about their hardware.
• Discovering the full fabric, including switches, endpoints, and dynamic links, gets complicated fast.
• Scaling and managing software-defined fabrics (where connections might change or be orchestrated on the fly) is tricky.
• Userspace tools have limited ability to query or manipulate the dynamic topology.

This fragmentation is especially problematic for large-scale AI clusters that need transparent, high-bandwidth communication between many different accelerators, sometimes with multi-vendor setups or new hardware on the horizon.

Introducing Intel DRM Fabric: Goals, Approach, and the New Model

Seeing these pain points, Intel engineers have stepped forward with the DRM Fabric proposal. Their goal? To create a vendor-agnostic, protocol-agnostic topology infrastructure “fabric” baked into the Linux DRM subsystem for managing scale-up interconnects. Rather than being another vendor-specific extension, DRM Fabric aims to be neutral ground—open to all vendors and future-proof.

DRM Fabric is designed to answer pressing needs:

• Abstract away vendor and protocol differences (e.g., PCIe, xGMI, UALink, NVLink) behind a generic, extensible topology model.
• Support both hardware-defined and software-defined fabrics, enabling dynamic, programmable topologies that can evolve without kernel restarts or driver rewrites.
• Expose topology and operational state to userspace, so orchestration software, monitoring tools, and system administrators can see (and, with privilege, modify) the live graph of available resources.
• Ensure robust, kernel-level API discipline and asynchronous notification—filling gaps not covered by sysfs or devlink in event-driven, multi-object environments.

The new fabric-endpoint-port-peer model lies at the heart of this effort.

Breaking Down the Fabric-Endpoint-Port-Peer Topology Model

The core concepts of the model are straightforward (but incredibly powerful):

• Fabric: A logical grouping of all endpoints that belong to one interconnect instance—a single “fabric” as defined by a provider (could be hardware-based or software-defined). Each fabric could represent, for instance, the PCIe fabric in a server, or a high-speed mesh for AI chips.
• Endpoint: Represents a single device (an accelerator, GPU, switch, etc.) attached to the fabric. Each endpoint can have multiple ports.
• Port: The actual physical connection point on an endpoint. Each port has “lane” capabilities (how much bandwidth it can offer), operational state (up/down, configured or not), and may have statistics or counters attached.
• Peer: A value that names the directly connected neighbor to a specific port—it could be an adjacent accelerator or a switch port. Peers can point to devices managed by another OS or domain, and do not guarantee end-to-end reachability (which stays with a higher-level orchestrator).

This model provides a hierarchical, graph-based view of the hardware topology without making policy decisions about routing or congestion control (which remain outside DRM Fabric’s scope).

Protocol and Implementation Decisions: Why Not sysfs or devlink?

For device state and control in Linux, sysfs and devlink are commonly used for device enumeration and control. However, in the context of complex, multi-object fabrics, these traditional interfaces come up short:

• sysfs: Struggles with live dump enumeration, event-driven notifications, and synchronizing state across multiple objects efficiently. It’s great for simple device attributes, not topologies.
• devlink: Assumes a primary device with subordinate objects—not a graph with independent endpoints potentially spanning vendor boundaries or being provisioned dynamically.

DRM Fabric sidesteps these issues by using Generic Netlink for its user/kernel API. Netlink is event-driven and multi-object aware, supports flexible notifications, and is better suited for the extensible YAML-based API discipline already introduced by DRM RAS (Reliability, Availability, Serviceability).

Patch Structure and Administration: Read-Only Discovery to Software-Defined Mutation

Intel’s proposal organizes the implementation into two milestones:

• Patches 1-6: Read-Only Topology Discovery. These patches allow kernel providers to publish the live fabric graph. Userspace can query objects, adjacencies, operational states, and statistics, but cannot modify the topology. This makes it safe to deploy for diagnostics and monitoring even before full provisioning support lands.
• Patches 7-12: Privileged Topology Provisioning. The second stage opens up privileged control for creating/removing fabrics, attaching endpoints, managing administrative state, and establishing or removing adjacencies (“mutation” operations such as fabric-new, fabric-del, endpoint-set, port-set, port-peer-new, and port-peer-del). Actual hardware programming is still deferred to the provider, ensuring that only permitted actors can rewire the fabric.

Crucially, administrative state (the “intent”) and operational state (the hardware-reported truth) are tracked distinctly, so userspace controllers can plan changes, stage configurations, and audit what’s really happening at the hardware level.

Everything You Need to Know About Ubuntu 25.10 “Questing Quokka”: Features, Changes, and Expert Insights

What DRM Fabric Does Not Do

To keep things clean and focused, Intel’s proposal is explicit about what DRM Fabric doesn’t handle:

• No network creation or route computation: The fabric doesn’t masquerade as a network or take ownership of transport layers, routing decisions, or congestion control.
• No switch policy, data transport, or MMU programming: These aspects remain with higher-level drivers, device firmware, or relay modules.
• No live migration or memory semantics: Out of scope for the neutral topology layer, these are the domain of device-specific or orchestrator-level logic.
• No initial production provider implementations: At RFC stage, the proposal focuses on the framework and API, not a complete working provider for any one hardware family.

This design philosophy keeps DRM Fabric small, sharp, and focused on its domain—making it easier for different hardware backends and user software to cooperate without duplicated effort.

Why Now? The Context: Competing Efforts, AI Acceleration, and the 2026 Landscape

Notably, Intel announced the DRM Fabric proposal only days after AMD posted its major UALink patchset for Linux, signaling rising urgency across the industry for a next-generation, neutral interconnect abstraction.

The timeline overlaps with Intel’s Crescent Island AI accelerator family, which is expected to require flexible, scalable topologies and dynamic software provisioning—a challenge that previous solutions like AMD’s xGMI tackled only for their own hardware. The fact that Intel’s team actively referenced AMDGPU xGMI in shaping the provider API speaks to the drive for interoperability and cross-vendor synergy.

Put simply, the pressure to seamlessly connect massive fleets of specialized accelerators, often with heterogeneous hardware and protocols, is shaping Linux’s upstream priorities for 2026 and beyond.

The Vendor-Neutral Dream: How DRM Fabric Bridges Proprietary Islands

AMD’s xGMI and UALink, Nvidia’s NVLink, and now Intel’s own forthcoming solutions represent a dizzying array of proprietary and semi-open interconnect architectures, each with its own quirks and discovery mechanisms.

But what happens when clusters get a mix of cards? Or when data-center operators require open standards to guarantee future-proof investments?

DRM Fabric’s “vendor-neutral, protocol-agnostic” approach gives kernel and userspace a universal topology language. Vendors keep their deep device programming and memory management specialties, but the topology discovery, representation, and (software-defined) mutation logic can become shared, interoperable, and forward-compatible.

If adopted, DRM Fabric could standardize how next-gen Linux kernels talk to both today’s and tomorrow’s accelerator fabrics, making complex, dynamic multi-vendor environments manageable and transparent.

Technical Deep Dive: API Design, Security, and Event-Driven Architecture

Generic Netlink forms the backbone of the user/kernel interface for DRM Fabric. Here’s why that matters:

• Netlink provides powerful event-driven communication between kernel and userspace, ideal for reacting to topology changes, device hotplug, or state transitions.
• Multi-object and hierarchical modeling become possible in a way that sysfs’s flat file representation or devlink’s rigid device-focused model cannot easily accommodate.
• Asynchronous notification support—critical in environments where a fabric can rapidly reconfigure (for instance, dynamic infrastructure or high-availability failovers).

On the API front, DRM Fabric’s discipline borrows from the YAML-described uAPI approach seen in recent Linux kernel innovations (like DRM RAS), allowing for clear specification and versioning of commands and data structures. También esté atento a las discusiones sobre qué es Kimi K3 para entender cómo los componentes de hardware de alta velocidad pueden integrarse en futuros topologías.

Regarding security, not all userspace actors are equal: querying live topology is safe for general diagnostics, but mutation (creating, attaching, rewiring endpoints) is only available to privileged userspace, tightly checked via kernel interface discipline and, where relevant, additional in-kernel authorization mechanisms.

Comparison: sysfs, devlink, and Why Previous Solutions Fell Short

Both sysfs and devlink have their roots in Linux device model management:

• sysfs is perfect for exposing static device properties but ill-suited for live, dynamic, multi-object graphs that AI and GPU fabrics require.
• devlink models subordinate objects directly tied to a parent device, but not networks of peers or software-defined endpoint clusters.

DRM Fabric’s strength lies in offering both the granularity (individual ports, endpoints, peer relationships) and the abstraction (fabric as a first-class object) necessary for modern large-scale accelerator fabrics.

Administrative State, Operational State, and Software-Defined Provider Patterns

Traditionally, the hardware provider driver is responsible for discovery and control—a pattern common in modern Linux graphics, storage, and networking stacks. However, in programmable accelerator fabrics, software may need to take the reins, especially in dynamic cloud or HPC scenarios.

DRM Fabric separates “administrative state” (the intended goal or desired topology) from the “operational state” (the hardware-reported status). This enables the following:

• Privileged userspace (such as orchestration software) can request, stage, and review topology changes.
• Providers (kernel-side) are the gatekeepers—enforcing permissions, synchronizing with hardware, and reporting true state as a source of truth.
• Mutation operations (creating or pruning endpoints, changing peers) are exposed in a controlled way, minimizing risk and maximizing flexibility for software-defined networks.

Testing, Community, and Next Steps

As of the initial RFC, DRM Fabric remains a work in progress—no production provider drivers have landed yet, and the focus is on perfecting the model and interface before backends or hardware-specific implementations appear.

The open-source spirit is alive and well: Intel’s patches and discussions are ongoing on the dri-devel mailing list, inviting feedback from other vendors, distro maintainers, and kernel hackers. The hope is that all major players (AMD, Nvidia, Intel, and perhaps others) will eventually converge on a shared infrastructure rather than a patchwork of divergent systems.

The timing aligns with future AI hardware launches, and the design is clearly based on lessons from AMD’s xGMI and the push for UALink, suggesting strong cross-vendor applicability.

DRM and the Foundations: How Linux Handles GPUs Today

To understand why DRM Fabric is both necessary and a leap forward, it helps to review what Linux already does well and where the pain points have been.

From its first appearance around 1999, DRM was all about letting multiple programs safely and efficiently share access to advanced GPU features—originally to support the X Window System, later expanding to Wayland compositors, GPGPU frameworks, and direct hardware access libraries like libdrm.

The classic DRM stack included several building blocks:

• DRM core: Vendor-neutral kernel functionality for basic device arbitration, buffer management, and minimal ioctls for all devices.
• DRM drivers: Vendor- and device-specific code that plugs in to the generic framework and handles hardware peculiarities.
• KMS (Kernel Mode Setting): Moved display control from userspace drivers to the kernel, enabling seamless multi-program usage, fast user switching, and consistent display experience across X, Wayland, and future desktop stacks.
• GEM (Graphics Execution Manager): Provided a simple, buffer-based memory management abstraction, particularly for Intel hardware, but soon adopted (and sometimes re-implemented) by other vendors for their chips.
• TTM (Translation Table Maps): A more feature-rich and memory-architecture-agnostic buffer object manager, favored by AMD and Nvidia open drivers.
• DMA-BUF and PRIME: Created the possibility for truly seamless DMA buffer sharing between different drivers and device families, including secure file-descriptor-based buffer passing.

These evolutions allowed Linux to outgrow its old “single-GPU-per-X-server” model and tackle real-world, multi-GPU, and even cloud-scale workloads. However, as soon as an interconnected cluster of accelerators (think eight AIs, two GPUs, and some custom ASICs) entered the chat, the standard device/file model reached its limits.

From Device Tree to Interconnect Graph: Why Topology Matters at Scale

In the old world, running ls /dev/dri/ would reveal a handful of cardX device nodes—easy when a server has one or two GPUs. Today, with dozens or even hundreds of interconnected devices, management by device file no longer suffices.

While Linux’s fbdev, KMS, and the multi-head API helped abstract basic display outputs, they don’t address the needs of AI accelerating mesh topologies, software-defined fabrics, or dynamic hotplug/removal. There’s a growing need to move away from implicit, flat device trees (what hardware is here now) to explicit, graph-based topologies (how is everything wired together, what protocols are used, what speed is available, how can we rewire or reassign devices on the fly, and who’s in charge?).

In production, this impacts:

• High-performance AI clusters that depend on consistent, high-bandwidth connections and must recover gracefully from failures or upgrades.
• Multi-tenant and cloud environments, where devices may be repurposed from one job to the next in seconds.
• Orchestrators and provisioning tools that determine how work is distributed, which endpoints are available, and which routes are permitted.

DRM Fabric fits here as a universal map-maker and gatekeeper, empowering both hardware-aware kernel modules and sophisticated userspace to keep up with accelerating innovation and complexity.

The Role of Generic Netlink and Event-Driven Topology Tracking

Why make such a big deal about Generic Netlink? In practical terms:

• Topology is rarely static. Switches may appear/disappear, endpoints might be hot-swapped, bandwidth negotiations happen, ports become unavailable. All these changes must be reported promptly to userspace orchestration software and potentially to hardware programming agents.
• Multi-object lifecycle management (such as adding/removing nodes, shuffling endpoints between fabrics, role reassignments) is more naturally handled by message-based, event-driven frameworks than by filesystem attributes.
• Netlink allows capturing notifications, acknowledgments, unicast and broadcast updates, and more—all vital for robust fabric management in large systems.

By leveraging Netlink, DRM Fabric creates a live, queryable, and mutable topology graph, with clear separation between discovery events, provisioning operations, and security boundaries.

Security, Trust Domains, and Inter-OS Cooperation

An important and sometimes overlooked aspect of the DRM Fabric proposal is its attention to trust boundaries and admin state separation:

• Peers may name endpoints in other trust domains (e.g., separate virtual machines or physical OSes), ensuring that the fabric model isn’t limited to the current kernel’s jurisdiction.
• Administrative intent (what an orchestrator wants) and operational state (what the hardware is actually doing) can diverge. DRM Fabric exposes both, allowing for verification, audit, and rollback when necessary.
• Mutation operations require explicit privilege. Even if userspace can see the fabric graph, only authorized software (like trusted control planes) can rewire it or create/destroy objects.

This design supports modern cloud and HPC setups where multiple tenants, zones, or OSes may share the underlying hardware—while keeping clear lines of responsibility and state serialization.

How Does DRM Fabric Fit with Other Linux Kernel API Developments?

Over the past decade, Linux has steadily adopted YAML-described uAPIs, event-based mechanisms, and extensible control interfaces in storage (NVMe Fabrics), networking (Devlink, Netlink), and memory management (CXL).

DRM Fabric is very much in tune with this movement, standing at the intersection of standardization, abstraction, and vendor-agnostic extensibility. The trend is toward giving userspace and device management tools standard, rich, and configurable interfaces that stay in sync with live hardware—without handing over all the keys by default.

Community and Kernel Development Process: The Road to Mainline Linux

Linux kernel development is famously open and iterative. The process for new subsystems or major changes involves:

• RFC (Request for Comments): Early-stage patches, as with DRM Fabric, are posted to relevant mailing lists for review and feedback from maintainers, hardware vendors, and other stakeholders.
• Iteration: Based on feedback, patches are refined, split, rebased, clarified, and occasionally re-architected multiple times.
• Vendor Engagement: For something as foundational as GPU/AI topology infrastructure, buy-in from the major hardware players (Intel, AMD, Nvidia, specialist AI start-ups) is essential.
• Landing in Mainline: Once a proposal matures, is well-tested, and fits kernel policy, it gets shepherded through DRM maintainers (e.g., Dave Airlie and others) to Linus Torvalds for potential merging into an upcoming kernel release.

Based on the rich history of DRM, KMS, GEM, DMA-BUF, and PRIME, there’s reason to believe DRM Fabric will follow a similar trajectory, potentially serving as the standard for next-gen interconnect topology by the mid/late 2020s.

Potential Use Cases: Who Will Benefit from DRM Fabric?

The implications of a production-hardened DRM Fabric API are far-reaching. Among the first and largest beneficiaries would be:

• AI and HPC Cluster Operators: Managing clusters with dozens-to-thousands of accelerators, requiring live reconfiguration, failover, and resource optimization.
• Linux Distributions and Cloud Providers: Packaging advanced orchestration tools that can interface with any vendor’s fabric, rather than shipping dozen vendor-specific utilities.
• Enterprise IT: Deploying dynamic GPU/accelerator pools for high-value workloads.
• Kernel Developers: Harmonizing code across vendors, simplifying maintenance, reducing duplicated effort on topology discovery and provisioning logic.
• AI Framework Developers: Deep learning and distributed compute toolchains can more easily leverage the full hardware landscape, scaling beyond vendor islands.

If the vision pans out, DRM Fabric could be to accelerator fabrics what PCI, SCSI, and NVMe are to storage: a lasting industry-wide standard that streamlines integration, boosts performance, and makes Linux the premier OS for composable infrastructure.

Vendor Agility and the Road to Cross-Platform Interoperability

While the original DRM subsystem was tightly coupled to display tasks, its evolution into a broader GPU and accelerator management platform marks a key inflection point. With the addition of flexible topology modeling, vendors can:

• Plug in new interconnect standards without kernel rewrites (futureproofing for, say, CXL-enabled accelerators or AI fabrics yet to be invented).
• Cooperate on discovery and state reporting standards, making scripting and automation more robust and less error-prone.
• Simplify support for multi-vendor clusters, reducing operational complexity and risk.

This agility is critical as the hardware landscape evolves at breakneck speed, and reinforces Linux’s position as both an innovator and a unifier in the world of professional compute.

From Reddit to Enterprise: Observing Market and Community Interest

As evident from trending discussions on Reddit, Phoronix, and the developer community, any shift in the Linux graphics and accelerator stack draws active, public scrutiny. On Reddit’s /r/linux, topics about DRM Fabric quickly spurred debate about whether Linux needed “another abstraction layer” or if this proposal could at last serve as a common ground between Intel, AMD, and any future AI/accelerator vendor.

While some skepticism persists (“Is this another proprietary layer, or does it actually invite cross-vendor participation?”), the technical consensus leans positive: the model appears carefully designed to address both present and anticipated needs, with sufficient openness for the community to steer its evolution.

Tying It All Together: The Growing Complexity (but Simplicity for Users)

In the past, GPU management was all about display outputs, single-stack manipulation, and making sure the X server didn’t crash. Those days are gone. We’ve entered an era where clusters of specialized hardware—and the fabric stitching them together—are as important as the individual compute power of each chip.

With the DRM Fabric proposal, Intel and the broader Linux community are working to make hardware topology as transparent, discoverable, and manageable as disks or networks have become. End-users—whether kernel developers, sysadmins, AI architects, or just power-users with exotic rigs—stand to gain reliability, clarity, and future-readiness.

As the landscape for Linux-based GPU and AI accelerator management continues to evolve, DRM Fabric aims to become a fundamental component that simplifies multi-vendor topologies, enhances scalability, and fosters an environment of open, interoperable high-performance systems.