Free and open-source graphics device driver

Lore & Background

Drivers without freely available source code are known as binary drivers. Binary drivers used in operating systems prone to ongoing development (such as Linux) create problems for end users and package maintainers, affecting system stability, security and performance. These problems are the main reason for the independent development of free and open-source drivers. When no technical documentation is available, an understanding of the underlying hardware is often gained by clean-room reverse engineering, allowing drivers to be written and legally published under any software license. In rare cases, a manufacturer's driver source code is available without a free license, meaning the code can be studied and altered for personal use but not freely distributed, reducing its utility compared to free and open-source drivers.

Objections to binary-only drivers include copyright, security, reliability and development concerns. OpenBSD lead developer Theo de Raadt stated that with a binary driver there is 'no way to fix it when it breaks (and it will break)'; when a product relying on binary drivers is declared end-of-life, it is effectively 'broken forever.' Binary drivers often do not work with current versions of open-source software and rarely support development snapshots. Features like kernel mode-setting cannot be added to binary drivers by anyone but the vendors. In the Linux kernel development community, Linus Torvalds said: 'I refuse to even consider tying my hands over some binary-only module ... I want people to know that when they use binary-only modules, it's their problem.' Greg Kroah-Hartman stated that a binary-only kernel module 'just violates the GPL due to fun things like derivative works and linking.'

From the hardware developer's view, when applications shunt calculations from the CPU to the GPU, they use a special-purpose API like OpenGL or Direct3D. Because all translation from API calls to GPU opcodes is done by the device driver, it contains specialized knowledge and is an object of optimization. The desktop computer market was long dominated by PC hardware with three major competitors (Nvidia, AMD and Intel). The mobile sector presents a different situation, with functional blocks as separate semiconductor intellectual property blocks on the chip. During the second quarter of 2013, 79.3% of smartphones sold worldwide were running Android, and the Linux kernel dominates smartphones. Hardware developers have an incentive to deliver Linux drivers but, due to competition, no incentive to make them free and open-source.

Reader's Guide

Free and open-source graphics device drivers are significant because they address fundamental problems of stability, security, and performance that arise from binary-only drivers, particularly in rapidly evolving operating systems like Linux. The article notes that binary drivers 'hide bugs and workarounds for bugs,' and that when a manufacturer declares a product end-of-life, it is effectively 'broken forever.' Free and open-source drivers, by contrast, allow anyone to study, alter, and redistribute the source code, enabling community-driven bug fixes and long-term hardware support. The Mesa project serves as the primary development hub for most such drivers. The architecture splits the driver into a Linux kernel component (DRM and KMS driver) and user-space components (libDRM and Mesa 3D), which translates API calls into GPU machine code. This separation allows independent development and integration with open-source software stacks. The article also highlights that in the mobile sector, where Linux dominates, hardware developers have incentives to deliver Linux drivers but not to make them free and open-source, creating ongoing tension. Projects like libhybris harness Android device drivers to run on other Linux platforms, illustrating the adaptability of open-source approaches. The legacy of free and open-source graphics drivers is their role in ensuring that graphics hardware remains usable and fixable beyond a vendor's support window, and in providing a transparent, community-driven alternative to proprietary binary blobs.

Purpose and Core Function

GDI served as the foundational graphics layer in Microsoft Windows, responsible for translating graphical objects into output for monitors and printers. Applications interacted with it through the Windows API to perform tasks like drawing lines and curves, rendering text, and managing color palettes. Even the USER subsystem relied on GDI to paint window frames and menus. Its most distinguishing strength was the abstract representation of target devices: a single drawing operation could be directed to a screen or a printer while expecting faithful reproduction on each. This device-agnostic approach sat at the heart of WYSIWYG applications on Windows. Other operating systems had analogous components—Mac OS employed QuickDraw, while Linux and Unix systems relied on the X Window System core protocol. Over time, GDI was gradually superseded first by the DirectDraw API and later by Direct2D, reflecting the industry's shift toward more modern graphics pipelines.

Technical Architecture

Under the hood, GDI organized its output pipeline around the concept of a device context, which encapsulated all the attributes governing how text and images would appear on a particular output device, whether that was a screen or a printer. The system maintained the actual context internally, while developers obtained a handle (HDC) to generate output and could release it once the operation completed. For geometric drawing, GDI employed a modified digital differential analyzer algorithm to render lines and curves, with the notable characteristic that it did not round coordinates to the nearest integer, preserving sub-pixel precision in its calculations. On Windows 3.1x and the 9x line, GDI could leverage bit blit capabilities for 2D acceleration when a compatible graphics card driver was present. The execution model also shifted over time: from Windows NT 4.0 onward, GDI ran in kernel mode, but with Windows Vista the Desktop Window Manager moved to user mode, altering where the compositing work took place.

Evolution Through Windows Versions

GDI shipped with the very first release of Windows, a critical departure from the MS-DOS era where programs manipulated video hardware directly through software interrupts or by writing to video memory—an approach that assumed exclusive access and was incompatible with multitasking. BYTE magazine discussed Microsoft's plans for unified printer-and-monitor output as early as December 1983. A major expansion arrived with Windows XP, which introduced GDI+, a C++-based layer adding anti-aliased 2D graphics, floating-point coordinates, gradient shading, complex path management, and native support for JPEG and PNG. It represented color using RGBA values and simplified vector-graphics implementations like Adobe Flash and SVG. The .NET Framework exposed GDI+ through the System.Drawing namespace. However, GDI+ text rendering was notably slower—tests showed roughly 16,600 glyphs per second versus 99,000 in plain GDI. Windows Vista then routed all GDI and GDI+ applications through the GPU-accelerated Desktop Window Manager, while Windows 7 reintroduced hardware acceleration for blitting operations via Display Driver Model v1.1.

Limitations and the GDI Printer Model

Despite its versatility, GDI had clear performance ceilings. It lacked a mechanism for synchronizing with individual video frames, offered no hardware rasterization for 3D content, and proved difficult to use for advanced animation. Simple games that did not demand rapid rendering could still rely on it, but modern titles turned to Direct3D, Vulkan, or OpenGL. The GDI printer concept extended this philosophy to output hardware: the host computer's GDI rendered each page as a bitmap, the printer driver processed and transmitted it, and the printer itself required no dedicated rendering hardware, firmware, or memory. Communication was bidirectional, with the printer reporting status such as paper-out or offline conditions. To simplify driver creation for these Winprinters, Microsoft developed the Universal Printer Driver, letting vendors describe printer capabilities in plaintext Generic Printer Description files without kernel-mode programming. Generic drivers like pnm2ppa attempted to bridge GDI printers to non-Windows systems such as FreeBSD, though full compatibility was not achievable.