A historical example of graphical user interface and applications common to the MIT X Consortium's distribution running under the twm window manager: X Terminal, Xbiff, xload and a graphical manual page browser

The X window system (commonly X Window System or X11, based on its current major version being 11) is a computer software system and network protocol that provides a basis for graphical user interfaces (GUIs) and rich input device capability for networked computers. It creates a hardware abstraction layer where software is written to use a generalized set of commands, allowing for device independence and reuse of programs on any computer that implements X.

X originated at the Massachusetts Institute of Technology (MIT) in 1984. The current protocol version, X11, appeared in September 1987. The X.Org Foundation leads the X project, with the current reference implementation, X.Org Server, available as free and open source software under the MIT License and similar permissive licenses.^[1]

Purpose and abilities[link]

X is an architecture-independent system for remote graphical user interfaces and rich input device capabilities which allows many people to share the processing power of a time-sharing computer and to collaborate with each other through client applications running on remote computers. Each person using a networked terminal has the ability to interact with the display with any type of user input device. Due to the ubiquity of support for X software on Unix, Linux and Mac OS X, X is commonly used to run client applications on personal computers even when there is no need for time-sharing.

X provides windowing on computer displays and manages keyboard, pointing device control functions and touchscreens. In its standard distribution it is a complete, albeit simple, display and interface solution which delivers a standard toolkit and protocol stack for building graphical user interfaces on most Unix-like operating systems and OpenVMS, and has been ported to many other contemporary general purpose operating systems.

X provides the basic framework, or primitives, for building such GUI environments: drawing and moving windows on the display and interacting with a mouse, keyboard or touchscreen. X does not mandate that the user interface be present – individual client programs known as window managers handle this. The window manager is not necessary and programs may use X's graphical abilities with no user interface. As such, the visual styling of X-based environments varies greatly; different programs may present radically different interfaces. X is built as an additional (application) abstraction layer on top of the operating system kernel.

Unlike most earlier display protocols, X was specifically designed to be used over network connections rather than on an integral or attached display device. X features network transparency: the machine where an application program (the client application) runs can differ from the user's local machine (the display server). X's network protocol is based on X command primitives and, with GLX, OpenGL 3D primitives rather than on a more basic framebuffer copying paradigm. This approach allows both 2D and 3D operations to be fully accelerated on the remote X server.

When used across the network, bandwidth and latency can both be significant issues in the usability of certain software models. Bandwidth is a key factor both in watching video in 2D and in transferring textures for 3D. Latency can be a concern in interactive applications – most obviously games – but for high levels of latency even basic menu manipulation can become difficult.

X provides no support for audio, although several projects exist in this niche, some also providing transparent network support. Some are PulseAudio, Advanced Linux Sound Architecture (ALSA), Open Sound System (OSS), and JACK Audio Connection Kit (JACK).

X also lacks support for user-defined stored procedures on the X server, which might have allowed for the dynamic construction of higher order primitives as seen in NeWS, which could reduce bandwidth demands from requiring fewer primitives to be sent, and improve certain types of interaction by removing round trips to the remote X client program in some varieties of menu interactions, picking, window management, and so on.

X is often used in conjunction with an X session manager to implement sessions. Usually, a session is started by the X display manager. However, the user can also start a session by manually running the xinit or startx programs.

Design[link]

Example deployment of X server: the X server receives input from a local keyboard and mouse and displays to a screen. A web browser and a terminal emulator run on the user's workstation and a software update application runs on a remote computer but is controlled and monitored from the user's machine

X uses a client–server model: an X server communicates with various client programs. The server accepts requests for graphical output (windows) and sends back user input (from keyboard, mouse, or touchscreen). The server may function as:

• an application displaying to a window of another display system
• a system program controlling the video output of a PC
• a dedicated piece of hardware.

This client–server terminology—the user's terminal being the server and the applications being the clients—often confuses new X users, because the terms appear reversed. But X takes the perspective of the application, rather than that of the end-user: X provides display and I/O services to applications, so it is a server; applications use these services, thus they are clients.

The communication protocol between server and client operates network-transparently: the client and server may run on the same machine or on different ones, possibly with different architectures and operating systems. A client and server can even communicate securely over the Internet by tunneling the connection over an encrypted network session.

An X client itself may emulate an X server by providing display services to other clients. This is known as "X nesting". Open-source clients such as Xnest and Xephyr support such X nesting.

To use an X client application on a remote machine, the user does the following:

• On the local machine, open a terminal window
• use ssh with the X forwarding argument to connect to the remote machine. Telnet can be used but is not secure, does not allow graphical forwarding and is largely deprecated.
• request local display/input service (e.g., export DISPLAY=[user's machine]:0 if not using SSH with X forwarding or 'tunneling' enabled).

The remote X client application will then make a connection to the user's local X server, providing display and input to the user.

Alternatively, the local machine may run a small program that connects to the remote machine and starts the client application.

Practical examples of remote clients include:

• administering a remote machine graphically
• using a client application to join with large numbers of other terminal users in collaborative workgroups.
• running a computationally intensive simulation on a remote machine and displaying the results on a local desktop machine
• running graphical software on several machines at once, controlled by a single display, keyboard and mouse.

Principles[link]

In 1984, Bob Scheifler and Jim Gettys set out the early principles of X:^[2]

• Do not add new functionality unless an implementor cannot complete a real application without it.
• It is as important to decide what a system is not as to decide what it is. Do not serve all the world's needs; rather, make the system extensible so that additional needs can be met in an upwardly compatible fashion.
• The only thing worse than generalizing from one example is generalizing from no examples at all.
• If a problem is not completely understood, it is probably best to provide no solution at all.
• If you can get 90 percent of the desired effect for 10 percent of the work, use the simpler solution. (See also Worse is better.)
• Isolate complexity as much as possible.
• Provide mechanism rather than policy. In particular, place user interface policy in the clients' hands.

The first principle was modified during the design of X11 to: "Do not add new functionality unless you know of some real application that will require it."^[2]

X has largely kept to these principles. The sample implementation is developed with a view to extension and improvement of the implementation, while remaining compatible with the original 1987 protocol.

User interfaces[link]

GNOME graphical user interface KDE Plasma graphical user interface

Xfce graphical user interface

X is primarily a protocol and graphics primitives definition and it deliberately contains no specification for application user interface design, such as button, menu, or window title bar styles. Instead, application software – such as window managers, GUI widget toolkits and desktop environments, or application-specific graphical user interfaces – define and provide such details. As a result, there is no typical X interface and several desktop environments have been popular among users.

A window manager controls the placement and appearance of application windows. This may result in desktop interfaces akin to those of Microsoft Windows or the Apple Macintosh (examples include Metacity in GNOME, KWin in KDE Software Compilation, Xfwm in Xfce, or Compiz) or have radically different controls (such as a tiling window manager, like wmii or Ratpoison). Window managers range in sophistication and complexity from the bare-bones (e.g., twm, the basic window manager supplied with X, or evilwm, an extremely light window manager) to the more comprehensive desktop environments such as Enlightenment and even to application-specific window managers for vertical markets such as point of sale.

Many users use X with a desktop environment, which, aside from the window manager, includes various applications using a consistent user interface. GNOME, KDE Software Compilation and Xfce are the most popular desktop environments. The Unix standard environment is the Common Desktop Environment (CDE). The freedesktop.org initiative addresses interoperability between desktops and the components needed for a competitive X desktop.

As X is responsible for keyboard and mouse interaction with graphical desktops, certain keyboard shortcuts have become associated with X. Control-Alt-Backspace typically terminates the currently running X session, while Control-Alt in conjunction with a function key switches to the associated virtual console. However, this detail is left to the design of an X server implementation and is not universal; for example, X server implementations for Windows and Macintosh typically do not provide these keyboard shortcuts.

Implementations[link]

The X.Org implementation serves as the canonical implementation of X. Due to liberal licensing, a number of variations, both free and open source and proprietary, have appeared. Commercial Unix vendors have tended to take the open source implementation and adapt it for their hardware, usually customizing it and adding proprietary extensions.

Up to 2004, XFree86 provided the most common X variant on free Unix-like systems. XFree86 started as a port of X for 386-compatible PCs and, by the end of the 1990s, had become the greatest source of technical innovation in X and the de facto standard of X development.^[3] Since 2004, however, the X.Org Server, a fork of XFree86, has become predominant.

While it is common to associate X with Unix, X servers also exist natively within other graphical environments. Hewlett-Packard's OpenVMS operating system includes a version of X with Common Desktop Environment (CDE), known as DECwindows, as its standard desktop environment. Apple's Mac OS X v10.3 (Panther) and v10.4 (Tiger) include X11.app, based on XFree86 4.3 and X11R6.6, with better Mac OS X integration. On Mac OS X v10.5 (Leopard), Apple included X.org (X11R7.2 codebase) instead of XFree86 (X11R6.8)^{[clarification needed]}. Third-party servers under Mac OS 7, 8 and 9 included Apple's MacX and White Pine Software's eXodus.

Microsoft Windows is not shipped with support for X, but many third-party implementations exist, as free and open source software such as Cygwin/X, Xming (free up to 6.9.0.31) and WeirdX; freeware such as Mocha X Server;^[4] and proprietary products such as Xmanager, Exceed, eXcursion (Hewlett-Packard), MKS X/Server, Reflection X, X-Win32 and Xming (current versions).

There are also Java implementations of X servers. WeirdX runs on any platform supporting Swing 1.1.*, and will run as an applet within most browsers. The Android X Server is an open source Java implementation that runs on Android devices.

When an operating system with a native windowing system hosts X in addition, the X system can either use its own normal desktop in a separate host window or it can run rootless, meaning the X desktop is hidden and the host windowing environment manages the geometry and appearance of the hosted X windows within the host screen.

X terminals[link]

A Network Computing Devices NCD-88k X terminal

An X terminal is a thin client that only runs an X server. This architecture became popular for building inexpensive terminal parks for many users to simultaneously use the same large computer server to execute application programs as clients of each user's X terminal. This use is very much aligned with the original intention of the MIT project.

X terminals explore the network (the local broadcast domain) using the X Display Manager Control Protocol to generate a list of available hosts that are allowed as clients. One of the client hosts should run an X display manager.

A limitation of X terminals and most thin clients is that they are not capable of any input or output other than the keyboard, mouse, and display. All relevant data is assumed to exist solely on the remote server, and the X terminal user has no methods available to save or load data from a local terminal device such as a floppy disk, CDROM, or USB storage device. However, printing is usually supported as a shared network or serial connection near the terminal.

Dedicated (hardware) X terminals have become less common; a PC or modern thin client with an X server typically provides the same functionality at the same, or lower, cost.

Limitations and criticism[link]

The UNIX-HATERS Handbook (1994) devoted a full chapter to the problems of X.^[5] Why X Is Not Our Ideal Window System (1990) by Gajewska, Manasse and McCormack detailed problems in the protocol with recommendations for improvement.

User interface issues[link]

The lack of design guidelines in X has resulted in several vastly different interfaces, and in applications that have not always worked well together. The Inter-Client Communication Conventions Manual (ICCCM), a specification for client interoperability, has a reputation as being difficult to implement correctly. Further standards efforts such as Motif and CDE did not alleviate problems. This has frustrated users and programmers.^[6] Graphics programmers now generally address consistency of application look and feel and communication by coding to a specific desktop environment or to a specific widget toolkit, which also avoids having to deal directly with the ICCCM.

Computer accessibility related issues[link]

Systems built upon the X windowing system may have accessibility issues that make utilization of a computer difficult for disabled users, including right click, double click, middle click, mouseover, and focus stealing. Some X11 clients deal with accessibility issues better than others, so those with accessibility problems are not locked out of using X11. However there is no accessibility standard or accessibility guidelines for X11. Within the X11 standards process there is no working group on accessibility, however, accessibility needs are being addressed by software projects to provide these features on top of X, including, Orca and ATK.

The Orca project^[discuss] is addressing needs for accessibility on X Window System desktops and has implemented an accessibility API called AT-SPI. ^[7] Because X is a extensible system and designed for flexibility and so that there are ways new features can be offered without necessarily having to be built into X itself, these features are being supported with new APIs that run alongside X window system. The Orca part of the system is the AT-SPI "server", various toolkits such as Gnome and GTK and other X Window System toolkits then add support for AT-SPI, giving a description on things on the screen over AT-SPI to Orca, which then reads them off. Any X11 GUI toolkit can support AT-SPI, support already exists in Qt and GTK. The creation of a special API has allowed for the inclusion of functions designed for the needs of a screen reading to describe to the user the layout of the screen, such as drop down boxes.^[8]

Gnome also has provided the ATK to allow for accessibility features to be implemented in X programs using the Gnome/GTK APIs.^[9]

Network[link]

Example of tunnelling an X11 application over SSH

An X client cannot generally be detached from one server and reattached to another unless its code specifically provides for it (emacs is one of the few common programs with this ability). By extension, moving an entire session from one X server to another is generally not possible. However, approaches like Virtual Network Computing (VNC), NX and Xpra allow a virtual session to be reached from different X servers (in a manner similar to GNU Screen in relation to terminals), and other applications and toolkits provide related facilities.^[10] Workarounds like x11vnc (VNC :0 viewers) and NX (nxagent's shadow mode) also exist to make the current X-server screen available via VNC and NX respectively. This ability allows the user interface (mouse, keyboard, monitor) of a running application to be switched from one location to another without stopping and restarting the application. This can be important in some applications, such as process monitoring and control.

Network traffic between an X server and remote X clients is not encrypted by default. An attacker with a packet sniffer can intercept it, making it possible to view anything displayed to or sent from the user's screen. The most common way to encrypt X traffic is to establish a Secure Shell (SSH) tunnel for communication.

Like all thin clients, when using X across a network, bandwidth limitations can impede the use of bitmap-intensive applications that require rapidly updating large portions of the screen with low latency, such as 3D animation or photo editing. Even a relatively small uncompressed 640x480x24bit 30fps video stream can easily outstrip the bandwidth of a 100Mbit network for a single client. Early versions of X would suffer even when not using the local network, such as when using a linux workstation with the X server and client on the same system, due to the network-centric protocol which would still utilize an internal network model within the computer, via localhost or unix sockets. In contrast, modern versions of X generally have extensions such as MESA allowing local display of a local program's graphics to be optimized to bypass the network model and directly control the video card, for use of full-screen video, rendered 3D applications, and other such applications.

Client–server separation[link]

X's design requires the clients and server to operate separately, and device independence and the separation of client and server incur overhead. Most of the overhead comes from network round-trip delay time between client and server (latency) rather than from the protocol itself: the best solutions to performance issues depend on efficient application design.^[11] A common criticism of X is that its network features result in excessive complexity and decreased performance if only used locally.

Modern X implementations use Unix domain sockets for efficient connections on the same host. Additionally shared memory (via the MIT-SHM extension) can be employed for faster client–server communication.^[12] However, the programmer must still explicitly activate and use the shared memory extension. It is also necessary to provide fallback paths in order to stay compatible with older implementations, and in order to communicate with non-local X servers.

Competitors[link]

Some people have attempted writing alternatives to and replacements for X. Historical alternatives include Sun's NeWS, which failed in the market, and NeXT's Display PostScript, both PostScript-based systems supporting user-definable display-side procedures, which X lacked. Mac OS X, iOS, and Android are the main Unix-like systems not using X for graphics.

When Apple Inc. bought NeXT, and used NeXTSTEP to construct Mac OS X, they replaced Display PostScript with Quartz. Mike Paquette, one of the authors of Quartz, explained why Apple did not move from Display PostScript to X, and chose instead to develop its own window server, by saying that once Apple added support for all the features it wanted to include into X11, it would not bear much resemblance to X11 nor be compatible with other servers anyway.^[13]

Wayland display server, hosted by freedesktop.org and developed by several X.Org developers, both addresses criticisms of X by replacing it completely and works directly with the hardware via DRI. It is planned for Wayland to eventually replace X in Ubuntu^[14] and Fedora,^[15] two well-known GNU/Linux distributions.^[16] Wayland handles backward compatibility with X by optionally running an X.org server as a client, which can be rootless (having one Wayland window per X client).^[17]

Other attempts to address criticisms of X by replacing it completely include Berlin/Fresco and the Y Window System. These alternatives have seen negligible take-up and have been abandoned by their developers; commentators widely doubt the viability of any replacement that does not preserve backward compatibility with X.

Other competitors attempt to avoid the overhead of X by working directly with the hardware. Such projects include DirectFB. The Direct Rendering Infrastructure (DRI), which aims to provide a reliable kernel-level interface to the framebuffer, may make these efforts redundant.^[18]

Other ways to achieve network transparency for graphical services include:

• the SVG Terminal, a protocol to update Scalable Vector Graphics (SVG) content in a browser in near-real-time
• Virtual Network Computing (VNC), a very low-level system which sends compressed bitmaps across the network; the Unix implementation includes an X server
• Citrix XenApp, an X-like product for Microsoft Windows
• Tarantella, which provides a Java client for use in web browsers
• RAWT, IBM's Java-only Remote AWT, which implements a Java "server" and simple hooks for any remote Java client.

MicroXwin is not a full-fledged replacement for X but maintains binary compatibility with standard X clients while providing better performance and significantly lower memory overhead by a different architecture of design that directly implements the system as a kernel module.^[19] The kernel module is proprietary while the user space libraries, libX11 (counterpart of Xlib) and libXext, are available under BSD style license.

History[link]

Predecessors[link]

Several bitmap display systems preceded X. From Xerox came the Alto (1973) and the Star (1981). From Apollo Computer came Display Manager (1981). From Apple came the Lisa (1983) and the Macintosh (1984). The Unix world had the Andrew Project (1982) and Rob Pike's Blit terminal (1982).

Carnegie-Mellon University produced a remote-access application called Alto Terminal, that displayed overlapping windows on the Xerox Alto, and made remote hosts (typically DEC VAX systems running Unix) responsible for handling window-exposure events and refreshing window contents as necessary.

X derives its name as a successor to a pre-1983 window system called W (the letter preceding X in the English alphabet). W ran under the V operating system. W used a network protocol supporting terminal and graphics windows, the server maintaining display lists.

Introduction[link]

X was introduced to the MIT Project Athena community in the following email^[20] in June 1984:

From: rws@mit-bold (Robert W. Scheifler)
To: window@athena
Subject: window system X
Date: 19 Jun 1984 0907-EDT (Tuesday)

I've spent the last couple weeks writing a window
system for the VS100. I stole a fair amount of code
from W, surrounded it with an asynchronous rather
than a synchronous interface, and called it X. Overall
performance appears to be about twice that of W. The
code seems fairly solid at this point, although there are
still some deficiencies to be fixed up.

We at LCS have stopped using W, and are now
actively building applications on X. Anyone else using
W should seriously consider switching. This is not the
ultimate window system, but I believe it is a good
starting point for experimentation. Right at the moment
there is a CLU (and an Argus) interface to X; a C
interface is in the works. The three existing
applications are a text editor (TED), an Argus I/O
interface, and a primitive window manager. There is
no documentation yet; anyone crazy enough to
volunteer? I may get around to it eventually.

Anyone interested in seeing a demo can drop by
NE43-531, although you may want to call 3-1945
first. Anyone who wants the code can come by with a
tape. Anyone interested in hacking deficiencies, feel
free to get in touch.

Origin and early development[link]

The original idea of X emerged at MIT in 1984 as a collaboration between Jim Gettys (of Project Athena) and Bob Scheifler (of the MIT Laboratory for Computer Science). Scheifler needed a usable display environment for debugging the Argus system. Project Athena (a joint project between Digital Equipment Corporation (DEC), MIT and IBM to provide easy access to computing resources for all students) needed a platform-independent graphics system to link together its heterogeneous multiple-vendor systems; the window system then under development in Carnegie Mellon University's Andrew Project did not make licenses available, and no alternatives existed.

The project solved this by creating a protocol that could both run local applications and call on remote resources. In mid-1983 an initial port of W to Unix ran at one-fifth of its speed under V; in May 1984, Scheifler replaced the synchronous protocol of W with an asynchronous protocol and the display lists with immediate mode graphics to make X version 1. X became the first windowing system environment to offer true hardware independence and vendor independence.

Scheifler, Gettys and Ron Newman set to work and X progressed rapidly. They released Version 6 in January 1985. DEC, then preparing to release its first Ultrix workstation, judged X the only windowing system likely to become available in time. DEC engineers ported X6 to DEC's QVSS display on MicroVAX.

In the second quarter of 1985, X acquired color support to function in the DEC VAXstation-II/GPX, forming what became version 9.

A group at Brown University ported version 9 to the IBM RT/PC, but problems with reading unaligned data on the RT forced an incompatible protocol change, leading to version 10 in late 1985. By 1986, outside organizations had begun asking for X. X10R2 was released in January 1986, then X10R3 in February 1986. Although MIT had licensed X6 to some outside groups for a fee, it decided at this time to license X10R3 and future versions under what became known as the MIT License, intending to popularize X further and, in return, hoping that many more applications would become available. X10R3 became the first version to achieve wide deployment, with both DEC and Hewlett-Packard releasing products based on it. Other groups ported X10 to Apollo and to Sun workstations and even to the IBM PC/AT. Demonstrations of the first commercial application for X (a mechanical computer-aided engineering system from Cognition Inc. that ran on VAXes and remotely displayed on PCs running an X server ported by Jim Fulton and Jan Hardenbergh) took place at the Autofact trade show at that time. The last version of X10, X10R4, appeared in December 1986.

Attempts were made to enable X servers as real-time collaboration devices, much as Virtual Network Computing (VNC) would later allow a desktop to be shared. One such early effort was Philip J. Gust's SharedX tool.

Although X10 offered interesting and powerful functionality, it had become obvious that the X protocol could use a more hardware-neutral redesign before it became too widely deployed, but MIT alone would not have the resources available for such a complete redesign. As it happened, DEC's Western Software Laboratory found itself between projects with an experienced team. Smokey Wallace of DEC WSL and Jim Gettys proposed that DEC WSL build X11 and make it freely available under the same terms as X9 and X10. This process started in May 1986, with the protocol finalized in August. Alpha testing of the software started in February 1987, beta-testing in May; the release of X11 finally occurred on 15 September 1987.

The X11 protocol design, led by Scheifler, was extensively discussed on open mailing lists on the nascent Internet that were bridged to USENET newsgroups. Gettys moved to California to help lead the X11 development work at WSL from DEC's Systems Research Center, where Phil Karlton and Susan Angebrandt led the X11 sample server design and implementation. X therefore represents one of the first very large-scale distributed free and open source software projects.

The MIT X Consortium and the X Consortium, Inc.[link]

In 1987, with the success of X11 becoming apparent, MIT wished to relinquish the stewardship of X, but at a June 1987 meeting with nine vendors, the vendors told MIT that they believed in the need for a neutral party to keep X from fragmenting in the marketplace. In January 1988, the MIT X Consortium formed as a non-profit vendor group, with Scheifler as director, to direct the future development of X in a neutral atmosphere inclusive of commercial and educational interests. Jim Fulton joined in January 1988 and Keith Packard in March 1988 as senior developers, with Jim focusing on Xlib, fonts, window managers, and utilities; and Keith re-implementing the server. Donna Converse, Chris D. Peterson, and Stephen Gildea joined later that year, focusing on toolkits and widget sets, working closely with Ralph Swick of MIT Project Athena. The MIT X Consortium produced several significant revisions to X11, the first (Release 2 – X11R2) in February 1988. Jay Hersh joined the staff in January 1991 to work on the PEX and X113D functionality. He was followed soon after by Ralph Mor (who also worked on PEX) and Dave Sternlicht. In 1993, as the MIT X Consortium prepared to depart from MIT, the staff were joined by R. Gary Cutbill, Kaleb Keithley, and David Wiggins.^[2]

In 1993, the X Consortium, Inc. (a non-profit corporation) formed as the successor to the MIT X Consortium. It released X11R6 on 16 May 1994. In 1995 it took on the development of the Motif toolkit and of the Common Desktop Environment for Unix systems. The X Consortium dissolved at the end of 1996, producing a final revision, X11R6.3, and a legacy of increasing commercial influence in the development.^[21][22]

The Open group[link]

In January 1997, the X Consortium passed stewardship of X to The Open Group, a vendor group formed in early 1996 by the merger of the Open Software Foundation and X/Open.

The Open Group released X11R6.4 in early 1998. Controversially, X11R6.4 departed from the traditional liberal licensing terms, as the Open Group sought to assure funding for the development of X.^[23] The new terms would have prevented its adoption by many projects (such as XFree86) and even by some commercial vendors. After XFree86 seemed poised to fork, the Open Group relicensed X11R6.4 under the traditional license in September 1998.^[24] The Open Group's last release came as X11R6.4 patch 3.

X.Org and XFree86[link]

XFree86 originated in 1992 from the X386 server for IBM PC compatibles included with X11R5 in 1991, written by Thomas Roell and Mark W. Snitily and donated to the MIT X Consortium by Snitily Graphics Consulting Services (SGCS). XFree86 evolved over time from just one port of X to the leading and most popular implementation and the de facto standard of X's development.^[3]

In May 1999, the Open Group formed X.Org. X.Org supervised the release of versions X11R6.5.1 onward. X development at this time had become moribund;^[25] most technical innovation since the X Consortium had dissolved had taken place in the XFree86 project.^[26] In 1999, the XFree86 team joined X.Org as an honorary (non-paying) member,^[27] encouraged by various hardware companies^[28] interested in using XFree86 with Linux and in its status as the most popular version of X.

By 2003, while the popularity of Linux (and hence the installed base of X) surged, X.Org remained inactive,^[29] and active development took place largely within XFree86. However, considerable dissent developed within XFree86. The XFree86 project suffered from a perception of a far too cathedral-like development model; developers could not get CVS commit access^[30][31] and vendors had to maintain extensive patch sets.^[32] In March 2003, the XFree86 organization expelled Keith Packard, who had joined XFree86 after the end of the original MIT X Consortium, with considerable ill feeling.^[33][34][35]

X.Org and XFree86 began discussing a reorganisation suited to properly nurturing the development of X.^[36][37][38] Jim Gettys had been pushing strongly for an open development model since at least 2000.^[39] Gettys, Packard and several others began discussing in detail the requirements for the effective governance of X with open development.

Finally, in an echo of the X11R6.4 licensing dispute, XFree86 released version 4.4 in February 2004 under a more restrictive license which many projects relying on X found unacceptable.^[40] The added clause to the license was based on the original BSD license's advertising clause, which was viewed by the Free Software Foundation and Debian as incompatible with the GNU General Public License.^[41] Other groups saw it as against the spirit of the original X. Theo de Raadt of OpenBSD, for instance, threatened to fork XFree86 citing license concerns.^[42] The license issue, combined with the difficulties in getting changes in, left many feeling the time was ripe for a fork.^[43]

The X.Org Foundation[link]

In early 2004, various people from X.Org and freedesktop.org formed the X.Org Foundation, and the Open Group gave it control of the x.org domain name. This marked a radical change in the governance of X. Whereas the stewards of X since 1988 (including the prior X.Org) had been vendor organizations, the Foundation was led by software developers and used community development based on the bazaar model, which relies on outside involvement. Membership was opened to individuals, with corporate membership being in the form of sponsorship. Several major corporations such as Hewlett-Packard currently support the X.Org Foundation.

The Foundation takes an oversight role over X development: technical decisions are made on their merits by achieving rough consensus among community members. Technical decisions are not made by the board of directors; in this sense, it is strongly modelled on the technically non-interventionist GNOME Foundation. The Foundation employs no developers.

The Foundation released X11R6.7, the X.Org Server, in April 2004, based on XFree86 4.4RC2 with X11R6.6 changes merged. Gettys and Packard had taken the last version of XFree86 under the old license and, by making a point of an open development model and retaining GPL compatibility, brought many of the old XFree86 developers on board.^[41]

X11R6.8 came out in September 2004. It added significant new features, including preliminary support for translucent windows and other sophisticated visual effects, screen magnifiers and thumbnailers, and facilities to integrate with 3D immersive display systems such as Sun's Project Looking Glass and the Croquet project. External applications called compositing window managers provide policy for the visual appearance.

On 21 December 2005,^[44] X.Org released X11R6.9, the monolithic source tree for legacy users, and X11R7.0, the same source code separated into independent modules, each maintainable in separate projects.^[45] The Foundation released X11R7.1 on 22 May 2006, about four months after 7.0, with considerable feature improvements.^[46]

On the other side, XFree86 is still being developed at a very slow pace, and version 4.8.0 was released on 15 December 2008.^[47]

Future directions[link]

The X.Org Foundation and freedesktop.org managed the main line of X development and they intend to provide more access to ubiquitous 3D hardware features. For sufficiently capable combinations of hardware and operating systems, X.Org plans to access the video hardware only via the Direct Rendering Infrastructure (DRI), using the 3D hardware. The DRI first appeared in XFree86 version 4.0 and became standard in X11R6.7 and later and this work is ongoing.^[48]

Nomenclature[link]

People in the computer trade commonly shorten the phrase "X Window System" to "X Window", "X11" (for version 11, used since 1987) or simply to "X".^[49] The term "X-Windows" (in the manner of "Microsoft Windows") is not officially endorsed, though it has been in common use since early in the history of X and has been used deliberately for provocative effect, for example in the UNIX-HATERS Handbook.^[5]

Release history[link]

Forthcoming releases[link]

See also[link]

Free software portal

• History of the graphical user interface
• X11 color names
• Xgl
• General Graphics Interface
• VirtualGL
• rio – the windowing system for Plan 9
• List of Unix programs
• DESQview/X
• Cairo (graphics)

Notes[link]

References[link]

External links[link]

Wikibooks has a book on the topic of Guide to X11

• X.Org Foundation Official website
• The X Window System: A Brief Introduction
• Window managers for X
• The State of Linux Graphics (Jon Smirl, 30 August 2005)
• Kenton Lee: Technical X Window System and Motif WWW Sites
• RFC 1198 – FYI on the X Window System

KDE desktop

A windowing system (or window system) is a component of a graphical user interface (GUI), and more specifically of a desktop environment, which supports the implementation of window managers, and provides basic support for graphics hardware, pointing devices such as mice, and keyboards. The mouse cursor is also generally drawn by the windowing system.

The term windowing system is sometimes used to refer to other elements of a graphical interface such as those belonging to window managers or even applications. While on some operating systems the distinction between applications, window managers, and their supporting technologies are blurred, strictly speaking, a windowing system does not include windows themselves.

From a programmer's point of view, a windowing system implements graphical primitives such as rendering fonts or drawing a line on the screen, effectively providing an abstraction of the graphics hardware from higher level elements of the graphical interface like window managers.

A windowing system enables the computer user to work with several programs at the same time. Each program runs in its own window, which is generally a rectangular area of the screen. Most windowing systems have basic support of re-parenting which allows windows to overlap, however the ways in which windows interact is usually controlled by the window manager.

Some windowing systems, like the X Window System, have advanced capabilities such as network transparency, allowing the user to display graphical applications running on a remote machine. The X Window System takes a strictly layered approach, and does not implement any specific policy regarding the look and feel of the graphical user interfaces, and their behaviour, leaving that to the X window managers, widget toolkits and desktop environments.

List of windowing systems[link]

[edit] For Unix-like operating systems

• 8½ and rio for Plan 9
• Fresco/Berlin
• FramebufferUI (fbui) in-kernel windowing system
• HP Windows
• ManaGeR (MGR)
• Metisse
• MicroXwin
• NeWS / OpenWindows
• NeXT DPS
• Qt Extended
• Quartz Compositor (Mac OS X)
• SunView
• Twin (Text WINdows)
• W Window System
• Wayland
• X Window System
• Xynth
• XFast
• Y Window System

[edit] Web windowing systems

• Dojo
• ExtJS
• TIBCO General Interface
• Web Window Manager

Other[link]

• DM
• GEM
• OPIE
• Intuition
• Microwindows
• MiniGUI
• OOHG

Operating systems such as Microsoft Windows, Mac OS (version 9 and earlier), and Palm OS, contain a windowing system which is integrated with the OS.

See also[link]

• History of the graphical user interface
• Widget toolkit
• Desktop environment