The History of XFree86

Take a stroll down Memory Lane and learn about XFree86 -- from its humble beginnings to its current status as the official X.

Today, when most desktop computer users see the word windows, they think of Microsoft’s operating system. That’s too bad, because long before Microsoft Windows was a twinkle in the eye of Bill Gates, Unix had its own windowing system — the X Window System.


The X Window System, more commonly referred to as simply X (but never as X Windows), is the set of device drivers and libraries that puts a graphical interface on most Unix systems. It was developed during the 80s, primarily for high-end, research-oriented hardware running in networked environments — but times have changed.

Nowadays, it’s not uncommon to find X running on commodity hardware, and when you do, the version you’re most likely to see is XFree86. XFree86 is a free implementation of the X Window System that has been under active development for over a decade. Any open source project that has been in active development for so long has to have an interesting history and cast of characters surrounding it, and XFree86 is no exception. So let’s take a look at X’s humble beginnings and follow its evolution into the Unix and Linux industry standard system it is today.


In its original incarnation, Unix, child of the console generation, lacked anything remotely resembling a graphical user interface. When personal computers arrived on the scene, they too followed the text-oriented approach with products like the Apple II.

In the 1980s, the introduction of the Apple Macintosh made everyone aware of the need for graphical interfaces on desktop computers. Around the same time, Microsoft began marketing its GUI-based OS, Windows. Both Microsoft Windows and the Macintosh failed to separate the duties of the OS and the windowing environment — the two were molded together.

In 1984, not long after the introduction of the Macintosh, the X Window System was born and Unix got its GUI. X took a fundamentally different approach to GUI design and implementation. From the beginning, X was designed to be used in a networked environment, and as such, was designed with a client/server model in mind. As a result, an X server makes no assumptions about its client’s rendering hardware.

This created obvious advantages (making remote computing feasible, for instance), some difficulties (putting security issues on the front burner), and some not-so-obvious drawbacks that would become more important as hardware capable of rendering 3D graphics became widespread. (See the Direct Rendering Infrastructure sidebar, pg. 29, for more on this topic.) And of course, the networked computers that X was originally designed to run on in 1984 were high-end (and extremely expensive) scientific workstations — definitely not the kind of machines the average user was likely to have lying around the house.

Sometime in 1989 or 1990, a German student named Thomas Roell began porting the source code for the X server provided in the X Version 11 Release 4 (X11R4) distribution to work with a graphics card he had installed in a 33 MHz Intel 386-based PC (with no floating point unit, mind you — this is old and slow hardware). He eventually released his X server, which he called X386.1.1. It caught the eye of some X developers at MIT, the X Consortium, and the Dell Unix team in Austin, Texas.

Dell brought Roell over to work on drivers for some graphics cards on a multiprocessor system that was to run a licensed version of Unix System V Release 4 (SVR4) for Intel systems. While he was at Dell, Roell worked with Stephen Gildea of the X Consortium and Mark Snitily of SGCS (Snitily Graphics Consulting Service). Together, they worked to take Roell’s next X server and make it the reference implementation for PC-based X Window Systems. When X11R5 was released on August 29, 1991, Roell and the X Consortium gave PC-based Unix its first official X implementation. And just in time too, as Linux had been born a few weeks earlier.

At one point, the X Consortium asked Roell to remove some assembly code from X386 that they felt was unnecessary. Roell retested the server on reasonably fast systems of the time, agreed with the X Consortium, and removed that bit of assembly code. This move was met with the disapproval of some in the community, but regardless, it was released as X386.1.2e. This was a pivotal point in the history of XFree86, as we’ll see in a moment.

Later, Roell decided the best way for him to get access to the cool graphics hardware of the time was to work with a commercial organization. He started working for Mark Snitily at SGCS, and this led him to take a leave of absence from the X386 project.


1984: X Window System development begins at MIT

1986: First commercial release of X (Version 10)

1988: The MIT X Consortium is formed

PRE-1991: X386.1.1 is released by Roell, but is not part of official X distribution

1990-1991: Roell works for Dell Unix team

1991: Roell joins SGCS, which later evolves into Xi Graphics

AUG 29, 1991: X386.1.2 is released with X11R5

MAY 7, 1992: X386 1.2E 0.0 is the first pre-XFree86 code by eventual team members

AUG 31, 1992: Last X386 tag, name change to XFree86

SEPT 2, 1992: XFree86 1.0m, first XFree86 tag

LATE 1993: XFree86 team begins in earnest to organize, seeking X Consortium access and membership

JAN 1994: The XFree86 Project joins the X Consortium

APR 26, 1994: XFree86 3.0 is the first release to work with X11R6

MAY 16, 1994: X11R6 is released

MAY 27, 1994: After long delay, XFree86 Project articles of incorporation become official

SEP 29, 1994: XFree86 version 3.1 is released

JULY 1, 1996: The Open Group assumes stewardship of X

OCT 26, 1996: XFree86 version 3.2 is released

LATE 1996: Metro Link donates loader technology to XFree86

APR 17, 1997: Work on new architecture begins with 3.9a

MAR 1998: Precision Insight is formed

MAR 31, 1998: The Open Group releases X11R6.4 under restrictive licensing

AUG 1998: DRI High Level Design is started

SEP 1998: The Open Group rescinds restrictive licensing for X11R6.4

OCT 5, 1998: XFree86 3.9Nh is merged with X11R6.4

DEC 1998: DRI Low Level Design is started

JAN 1999: Initial DRI implementation begins

FEB 1, 1999: MESA 3.1 to be released under XFree86/ BSD/MIT style license

FEB 16, 1999: SGI releases GLX to open source

MAY 12, 1999: DRI Low Level Design documents are available

MAY 12, 1999: The Open Group forms and assigns it stewardship of X

JUN 1999: DRI 1.0 implementation is released

NOV 1999: XFree86 Project is made Honorary Member of

MAR 8, 2000: XFree86 version 4.0 is released

MID-2000: SGI donates GLX and font technologies to XFree86

OCT 27, 2000: X Render Extension shows up in XFree86 4.0.1d

JUN 2001: XFree86 4.1 released


Enter “The Gang of Four.” Four people from different walks of life were brought together by their common interest in modifying the X386 server. Jim Tsillas was working on an open source solution derived from Roell’s original work; he decided the missing assembly was better for performance reasons and put it back into his version of X386. Glenn G. Lai also reinstated the missing assembly code into his own version for the same reasons. Meanwhile, David Wexelblat of AT&T Bell Labs and David Dawes, then a physics student at the University of Sydney in Australia, had been working separately on projects to fix bugs and improve reliability.

It didn’t take long for the four to find out about each other’s projects. When they realized they were duplicating a lot of effort, they decided it would be in everyone’s best interest to join forces. Thus, “The Gang of Four” (as they were dubbed by Mark Snitily of SGCS) was born.

The Gang of Four worked on their newly merged project, which was a fork from the X11R5 version of X386. However, this didn’t stop them from merging changes from the X11R5 source as they went. X386.1.2e, as it happens, was the first set of code to be checked into the source tree for the yet-to-be-formed XFree86 Project. The date was May 7, 1992.

Roell had already acquired the term “X386″ for his project, so to avoid confusion, Wexelblat, Dawes, and their growing group of developers decided to find a new name for their project. The “Free” part of XFree86 was a pun on the ori-ginal name “X386,” though as Wexelblat says, “No one real-ly gets it anymore.” He also notes that the term “XFree” is incorrect — it’s been “XFree86″ since he coined the term, even though the “86″ is a bit of a misnomer since they support systems beyond the Intel x86 platform. The last check-in under the name “X386″ was on August 30, 1992; two days later, the very first branch of XFree86 was tagged.

By the late 1980s, the X Consortium, which included workstation vendors like IBM, AT&T, DEC, Sun, and Hewlett-Packard, began working in conjunction with MIT’s X development team. At this point, the group had full control over the design and development of the X Window System. The work done on X by the Consortium became a de facto open standard for graphical interfaces on high-end workstations.

But while much development was done early on, by the mid-90s, work from the X Consortium had slowed to a trickle. Workstation vendors, addressing the newer RISC architectures of the time, weren’t as focused on graphics issues.

The XFree86 Project, on the other hand, being free from the X Consortium’s distractions, continued to address the needs of the growing open source community. They also focused primarily (but not completely) on the fledgling Intel-based PC architecture, a hardware architecture overlooked by the original X Consortium members.

Despite the progress the XFree86 team was making, they found themselves at a disadvantage. Not being members of the X Consortium meant they had access only to the (infrequently) released source code. To get access to the latest, bleeding-edge code, they would have to become members of the X Consortium.

This wasn’t easy, because XFree86 wasn’t even a formal organization; furthermore, it had no way to pay the expensive membership fee charged by the X Consortium. Without a sponsoring workstation partner, XFree86 remained on the outside looking in.

Late in 1993, while the X Consortium was working away on its coming X11R6 release, the core development team for XFree86 began to pursue different approaches to joining. Wexelblat explained:

“This whole concept of a corporation for a freeware project was pretty novel — we were one of the first to do such a thing. We actually explored two avenues — finding a sponsoring company (e.g., NCR might well have done it) or forming our own. Since we had no funds, we had to solicit funding. This was tricky stuff in those early days; we had to be careful not to alienate the nascent open source constituency by doing things that smacked of taking money for free software (which was largely unheard of at the time). We put some feelers out on NetNews to see if we could find 10 sponsors to come up with $500 each, to give us the $5,000 we needed to join The X Consortium.

“I immediately got a response from John Gilmore at Cygnus, who volunteered the entire $5,000 if we would put XFree86 under GPL. I just as quickly refused, as (a) we had no interest in GPL whatsoever (I could go on for days on the history of our debates back then), and (b) even if we had wanted to use GPL, we were a patch kit that ran on top of an open source project under a different license, which [made it] impossible.

“Very shortly thereafter, I was contacted by Rick Adams, president of UUNET at the time, who simply asked for details and then sent me a $5,000 check for the fee basically on the spot.”

The group then filed their articles of incorporation for the project. Wexelblat and Dawes joined with Dirk Hohndel, Dr. Richard Murphey, Dr. Jon Tombs, Glenn Lai, and James Tsillas to register the XFree86 Project, Inc. in the state of Texas. They filed their articles of incorporation in January 1994. That, combined with UUNet’s corporate sponsorship, allowed the new XFree86 Project to officially join the X Consortium. Soon after, on April 25, 1994, XFree86 3.0 was born. This was the first release to work with the newly announced X11R6 standard.

The announcement of the filing and membership in the X Consortium is noted in Linux Journal‘s second issue, June 1994. The event marked the rise of the PC Unix market, as later that same year Red Hat Linux was introduced (with Red Hat, Inc. launching in early 1995). Slackware Pro and other major distributions followed soon after.


X has a client/server architecture that uses a relatively slow transport mechanism to deliver rendering commands from the client to the server. All this is done through the Xlib library.

Using that transport to handle 3D graphics is impractical — it just takes too long for the round-trip communications. Life would be simpler if the clients could talk directly to the graphics hardware. Unfortunately, X was designed specifically to avoid that scenario.

Instead of using Xlib calls to pass rendering requests through X, DRI uses a shortcut through a kernel driver that knows how to talk directly to the hardware. Clients still need to be well-behaved X clients that share X resources with other 2D and 3D X clients. Coordinating those resources is done via X, but the actual rendering (or displaying to the screen) is done directly through the kernel-level driver.

This means that with DRI, graphics driver developers can now put code into the DRI kernel driver, the client DRI driver library, or the X server — wherever it is most appropriate for both security and performance’s sake. This is a more flexible architecture than early XFree86 implementations, and it allows modern 3D graphics hardware to be supported easier and quicker. This is a big win for people who want to run high-speed animation tools (like Houdini) or play the latest 3D games.


Standards groups come and go, and the X Consortium was certainly no exception. With its founding members finding their niches in different parts of the computing world, little actual work was being done by the Consortium on the X core code by 1995. Still, some members felt driven to continue work on X, especially those companies that had begun to see the value of the PC in a larger desktop market economy.

On July 1, 1996, management of X was handed over to The Open Group, whose goal it was to standardize various open architectures, including the X Window System. Unfortunately, like Unix’s parent Bell Labs before it, The Open Group simply didn’t understand the economics of the PC marketplace.

The Open Group changed the licensing of the X11R6.4 release to require per-user fees for commercial distribution. This meant that while XFree86 could continue to distribute its code to Linux vendors, vendors would have to charge for each copy they sold. This essentially eliminated XFree86′s ability to continue to participate with The Open Group.

However, little work was being done by The Open Group on X at the time anyway, and the XFree86 Project had relatively little to gain by continuing to work with it. In a bold move, the project simply stopped integrating new features from The Open Group’s reference implementation of X into the XFree86 source tree. This circumvented the new licensing issues.

The Open Group tried to recover from the backlash by reverting to the original licensing policy and launching the group, but significant damage was already done. Shortly after the restrictions were made, The Open Group’s X development shrunk rapidly, and it released most of its X developers. Official X went on hold.

Meanwhile, XFree86 development was going strong. Of all the original X Consortium members, the XFree86 team was the only one left doing any real work on X, so in a strange twist of fate, the future of X now rested in the hands of the XFree86 team.


THOMAS ROELL developer of X386, a predecessor to XFree86. Later worked with Mark Snitily of Snitily Graphics Consulting Service and Stephen Gildea of the X Consortium to develop an official X version for Intel hardware. Now CTO of Xi Graphics, developer of accelerated X servers.

THE MIT X CONSORTIUM / THE X CONSORTIUM, INC. / THE OPEN GROUP / X.ORG official steward of the X standard. (Current Members: Compaq, Hewlett-Packard, Hummingbird, IBM, SGI, Sun Microsystems, Attachmate, Metro Link, Mitre, Naval Surface Warfare Center, Xi Graphics, BarCo, ICS, Shiman Associates, Starnet, WRQ. Honorary Member: The XFree86 Project Inc.).

XFREE86 “GANG OF FOUR” (Jim Tsillas, Glenn G. Lai, David Wexelblat, David Dawes) — initial developers of XFree86.

XFREE86 PROJECT INC. (“Gang of Four” plus Dirk Hohndel, Dr. Richard Murphey and Dr. Jon Tombs) — steward of XFree86.

PRECISION INSIGHT (Jens Owen, Frank LaMonica, Kevin Martin, Daryll Strauss, Brian Paul, Rik Faith, Allen Akin) — developer of Direct Rendering Infrastructure technology.

METRO LINK donated loader technology to XFree86.


While the XFree86 Project shines brightly as a model for open source development, the developers did not travel down the path of success all by themselves. In order to reach their milestone 4.0 release, the XFree86 team looked to many corporate friends.

Corporate involvement with XFree86 goes back to the very beginning, when companies like Xi Graphics, Metro Link, Pittsburgh Power Computing, NCR, and Unix Systems Laboratories (USL) all worked closely with Wexelblat, Dawes, and the other developers. It was not unusual to see cross-pollination between these companies and the XFree86 Project through the developers who were paid by one and volunteered for the other.

Even Thomas Roell (who got it all started with X386) was still working on X-related issues. Last we left him, he was at SGCS. Since then, he and another employee of SGCS bought the company and changed the name to X Inside, and then later, to Xi Graphics. He continues as the Chief Technology Officer of Xi Graphics, but they mostly compete with XFree86 these days.

Other corporate contributions have been quite generous to the project at times. For example, a rather significant contribution was made in late 1996, when Metro Link decided to donate its loader technology by way of a longtime XFree86 associate, Stuart Anderson.

This technology became a focal point for a major redesign of the XFree86 server code, and this new architecture would come to fruition three years later as XFree86 4.0. In addition to Metro Link, there was another company that played an important role in helping to shape XFree86 4.0 — Precision Insight.

Precision Insight was, for all practical purposes, the heart of X and graphics in the Linux world through the release of XFree86 4.0. Headquartered in Steamboat Springs, Colorado, Precision Insight was formed in early 1998 by Jens Owen and Frank LaMonica, both ex-employees of Roell’s Denver-based Xi Graphics.

Owens approached a longtime XFree86 developer, Kevin Martin, in April 1998 about joining the Precision team, and soon after Martin became the first of many high-profile graphics engineers hired by the new company. Precision also employed the likes of 3Dfx guru Daryll Strauss, Mesa author Brian Paul, Rik Faith (an XFree86 developer who had been with the project nearly from its inception), and Allen Akin (who helped bring X and the PEX 3D extension to life while at Digital Equipment Corporation).

The long-term focus for Precision Insight was to move the PC-based X world into 3D. However, to raise funding, they decided to initially leveraged their longstanding 2D driver experience to get X into laptops, concentrating on systems using the popular NeoMagic chipset.

With help from Red Hat, Precision released their NeoMagic support in the summer of 1998. Now that they had secured some funding, they immediately returned to their long-term goal of bringing 3D to the masses who used XFree86.

They began to write up a high-level specification — now known as the Direct Rendering Infrastructure — to provide a foundation for the more advanced work they wanted to do in 3D. The low-level design review for a new XFree86 architecture designed by Precision occurred in December 1998, with driver development beginning immediately after.

VA Linux Systems purchased Precision Insight in the spring of 2000, when that high-flying hardware company thought it would be beneficial to have a stronger graphics presence in the desktop computing marketplace. Since then, the team has left VA Linux following that company’s layoffs and restructuring, but the development of XFree86 continues anyway.

XFree86 4.0 was released with much fanfare in March 2000. It was the last major release of the XFree86 distribution and was a major milestone in the history of X.


Today, XFree86 is considered to be among the most successful open source projects in existence. It provides the graphical foundation for practically all the free Unix systems, so it enjoys wide distribution. XFree86 4.0 ships with most modern Linux distributions. However, because not all old hardware is still available for testing, some video cards may not be supported by the new X server. Because of that, many distributions still ship the older XFree86 3.3.x as well.

While there is a formally registered organization for XFree86, very little work actually goes on at that level since there is no product to be marketed or sold directly by the team. Most work done on XFree86 is done at the core team level, where the overall technical direction is handled for the project. The team members continue to work as they did when the project was born — via phone and e-mail. The XFree86 Technical Conference this year was held in Oakland in conjunction with the Annual Linux Showcase in November for hands on, high-energy development and bug fixing.

The XFree86 Project is still in high gear today. The latest advances include video support with the X Video Extension, support for using multiple monitors and video cards simultaneously (aka “multiheaded display support”) with a feature called Xinerama, and smooth font display using the X Render Extension. Technologies like these will keep X strong and alive for many years to come, with the XFree86 team as the driving force in the world of X.


Michael J. Hammel is the author of Artists’ Guide to the GIMP. He can be reached at

Fatal error: Call to undefined function aa_author_bios() in /opt/apache/dms/b2b/ on line 62