1 Architecture

X is based on a client-server model. A client application runs on a computer 'host' and communicates with various X servers running on remote PCs or X terminals, accepting requests for graphical output (windows) and user input (keyboard, mouse).

This client-server terminology — your terminal is the "server", the remote applications are the "clients" — often confuses new X users, because the terms appear reversed. But X takes the perspective of the program, rather than the end-user or the hardware: the remote programs connect to the X server display running on the local machine, and thus act as clients; the local X display accepts incoming traffic, and thus acts as a server.

The communication protocol between server and client runs 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 using the secure shell (SSH) which implements port forwarding so as to tunnel X securely over a TCP/IP connection.

Practical examples include: running a computationally intensive simulation on a remote Unix machine and displaying the results on a local Windows desktop machine; administering a remote machine graphically; running graphical software on several machines at once, controlled by a single display, keyboard and mouse.

2 Implementations

The canonical implementation of X is the X.Org reference implementation. This is available under the open source MIT License and similar permissive licenses.

Due to the liberal licensing, a number of implementations both free and proprietary, have appeared, based on the code from X.Org. Commercial Unix vendors tend to take the X.Org reference implementation and adapt it for their hardware, usually customising it heavily and adding proprietary extensions. One commercial implementation not tied to a hardware vendor is Accelerated-X.

Up to 2004, the most common X variant on free Unix-like systems was XFree86. This originated from the X386 server included with the reference implementation, hence the name. The current most popular open source X server is the current X.Org reference implementation, the XOrg Foundation Open Source Public Implementation of X11, a fork of XFree86.

While X is most often associated with Unix, X servers also exist natively within other graphical environments such as DESQView/X, OS/2, and Mac OS.

Hewlett-Packard's OpenVMS operating system includes a version of X with the CDE desktop, known as DECwindows, as its standard desktop environment. Mac OS X 10.3 (Panther) includes Apple's version of X11, based on XFree86 4.3 and X11R6.6, with better Mac OS X integration. Servers for Microsoft Windows include Cygwin/X, Exceed, XVision , X-Win32 and WeirdX.

2.1 X terminals

An X terminal is a piece of dedicated hardware running an X server as a thin client. This architecture became popular for building inexpensive client parks for many users to simultaneously use the same large server. This use very much aligns with the original intention of the MIT project.

X terminals explore the network using XDMCP to connect to a specific server which presents a list of available hosts. This server in turn may gather a list of available hosts using broadcast on the local network.

Dedicated (hardware) X terminals are no longer common; the same functionality is typically provided at a lower cost with either a user's Microsoft Windows PC running an X server program or a low-end PC running Linux.

3 Common criticisms of X

The device independence and separation of client and server does incur an overhead. X's network transparency requires the clients and server to operate separately. This gave a significant performance penalty compared to more integrated systems like MacOS (versions 1 to 9) or Windows. In the early days, 8 to 16 MB of RAM was recommended for reasonable performance; until the mid-1990s, this was regarded as bloated compared to Microsoft Windows or Mac OS, where windowing was deeply embedded in the operating system.

(In the present day, both Windows and Mac OS X Quartz have internal subsystem separation similar to the client/server divide in X — Moore's Law having increased memory and CPU power to the point where the increased flexibility and programmability of such a model compensates for its resource consumption.)

As per "mechanism, not policy," X deliberately contains no specification as to application appearance or most inter-application communication. The result was several vastly different interfaces, and applications that did not quite work together. The ICCCM, a specification for client interoperability, is notorious for having a difficult and confusing API. Further standards efforts such as Motif and CDE did not remedy matters. This has long been a source of great frustration to users and programmers [1]. Consistency of application look and feel and communication is being addressed by desktop environments, which have strong interface guidelines, and interoperability between different desktop environments is being addressed by the freedesktop.org initiative. Programming to a given toolkit or desktop environment helps avoid having to deal directly with the ICCCM.

Hardware support remains a problem. The performance edge for graphical computing is now in the most advanced graphics functions, which are typically implemented in proprietary drivers written by the manufacturers, and generally for Windows (the largest consumer market) first.

X does not include good support for sound. As users increasingly expect sound, this has led to various incompatible sound subsystems. Most programmers in the past have chosen to ignore the issue of network sound and simply use local, OS-specific sound APIs. This is fine for workstation systems, but does not provide a mechanism for network-transparent audio. More recent efforts by the KDE and GNOME projects have resulted in two common network sound systems, ESD and ARts, although these are by no means standard. Freedesktop.org and the X.Org Foundation are working on a suitable system ( MAS ) that will be part of, or more closely linked to, X itself.

X does not include a good solution to printing what you see on the screen. X11R6.3 included a print extension, but it was not widely used. Most X clients print to PostScript entirely separately from what they send to the server.

An X client or session cannot be detached from one server and reattached to another, as with VNC. Work is under way to add this facility to X.

The UNIX-HATERS Handbook devoted an entire chapter, "The X Windows Disaster", to the problems of X in the late 1980s and early 1990s.

4 Competitors to X

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, which eventually turned into Apple's Quartz for Mac OS X.

Modern attempts to address criticisms of X by replacing it completely include Berlin/ Fresco and the Y Window System. None of these systems have had more than negligible uptake, however. At present, any alternative to X is considered unlikely to replace X without full backward compatibility.

Others attempt to avoid the overhead of X by working directly with the hardware. Such projects include DirectFB. The Direct Rendering Infrastructure module in X (introduced in XFree86 version 4 and present in X11R6.7 and later) performs a similar function.

Other attempts to achieve network transparency in the form of graphical terminal services include VNC (a very low-level system which blasts bitmaps across the network; the Unix implementation includes an X server), Citrix MetaFrame (an X-like product for Windows) and Tarantella (which provides a Java client for use in web browsers).

5 History

5.1 Predecessors

There were several bitmap display systems before X. From Xerox came the Alto (1973) and the Star (1981). From Apple came the Lisa (1983) and the Macintosh (1984). In the UNIX world there was the Andrew Project (1982) and Rob Pike's Blit (1984).

X derives its name as a successor to a pre-1983 window system called W (the letter X directly following W in the Latin alphabet). W ran under the V operating system.

5.2 Origin and early development

X was initially conceived at MIT in 1984 as a collaboration between Jim Gettys of Project Athena and Bob Scheifler of the MIT Laboratory for Computer Science. Project Athena was a joint project between Digital Equipment Corporation, MIT and IBM to provide easy access to computing resources for all students. Project Athena needed a platform-independent graphics system to link together its heterogeneous systems of multiple vendors and no alternatives were available as the window system being developed in the Andrew Project was not available for licensing.

The project solved this by creating a protocol that could run local applications and was able to call on remote resources. X was born in June 1984, when Bob Scheifler replaced the synchronous protocol of W with an asynchronous protocol and replaced the display lists with immediate mode graphics to make X version 1. X was the first window system environment that was truly hardware and vendor independent.

X progressed rapidly, version 6 being released January 1985. This version was ported to DEC's QVSS display on MicroVAX . Color support was added a few months later to support the DEC VAXstation -II/GPX, forming what became version 9.

Version 9 was released in September 1985. 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. By 1986, outside organizations were asking for X. X10R3 was released in January 1986 and was the first version to achieve wide deployment. X10R4 was the last version of X10. Significant issues in the base protocol made it clear that a redesign of X, before it was too widely deployed, was desirable, but the scale of such a project was beyond the resources available at MIT alone.

Smokey Wallace of DEC's WSL and Jim Gettys proposed that X11 be built at DEC's WSL and made freely available under the same terms as previous versions of X. It was started in May 1986 and released in September 1987. The protocol design was lead by Bob Scheifler and extensively discussed on open mailing lists on the nascent Internet.

X therefore represents one of the first very large scale open source software projects.

5.3 The X Consortium

In 1988, with the success of X11 becoming apparent, the (MIT) X Consortium (a non-profit vendor group) was formed to direct the future development of X in an atmosphere inclusive of commercial and educational interests. The X Consortium produced several significant revisions to X11, the first being Release 2 (X11R2) in 1988 and the last being Release 6 in 1994 (X11R6). The Consortium dissolved at the end of 1996, producing a final small revision, X11R6.3.

5.4 The Open Group and X.Org

In mid-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 ( OSF) 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 X's development. The new terms would have prevented its adoption by many projects (such as XFree86) and even some commercial vendors. After XFree86 threatened a fork, X11R6.4 was relicensed under the traditional license in September 1998. [2]

In May 1999, the Open Group formed X.Org. X.Org supervised the release of versions X11R6.5.1 onward.

5.5 The X.Org Foundation

In early 2004, the X.Org Foundation was formed. This marked a radical change in the governance of X. Whereas the stewards of X since 1988 (including the previous X.Org) had been vendor organizations, the Foundation is led by software developers and using community development on the bazaar model, which relies on outside involvement. Membership is also open to individuals, with corporate membership being in the form of sponsorship.

X11R6.7 was released in April 2004, based on XFree86 4.4RC2 and X11R6.6. Present and future releases are intended as usable finished products, not merely a base for vendors to build a product upon. The reference implementation is now being developed with a view to significant extension and improvement of the implementation, whilst remaining almost entirely compatible with the original 1987 protocol.

X11R6.8 and X11R6.8.1 (a security fix) were released in September 2004. X11R6.8 adds significant new features to X, 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 . Policy for the visual appearance is not hardwired, but is provided by external applications called compositing managers.

6 Nomenclature

"X Window System" is commonly shortened to "X11" or simply "X." The term "X Windows" (in the manner of "Microsoft Windows") is officially deprecated and generally considered incorrect, though it has been in common use since the inception of X and has been used deliberately for literary effect, e.g. in the UNIX-HATERS Handbook.

7 Technical details

7.1 X services and protocol interactions

The X server provides only the following. All else is provided by client programs.

• Input handling: Keyboard and mouse input are passed to clients as events via the window manager—which, as far as X is concerned, is just another client.
• Window services: Clients ask the server to create or destroy windows. Windows may be nested hierarchically. Clients can request information about windows.
• Text and fonts: Clients ask for text to be drawn at a given location in a given font. The client can request information on available fonts.
• Graphics: Clients ask the server to draw pixels, lines or shapes or perform bitmap operations.
• Resource management: The X resource manager provides a content addressable database for clients. Clients can be implemented so they are customizable on a system and user basis.

There are four types of communication between X clients and the server:

1. Request: The client requests an action or information.
2. Reply: The server responds. Note that not all requests generate replies.
3. Event: The server sends an event to the client, e.g. keyboard or mouse input, or a window being moved, resized or exposed.
4. Error: The server sends an error packet if a request is invalid. Note that requests are queued, so an error packet may not be sent immediately.

7.2 X Display Managers

The X Display Manager keeps the X server process alive on the X server machine, connecting it to a physical screen and serving a login prompt on this screen.

XDM serves as the default display manager for X, but other projects have developed their own display managers:

• XDM
• GDM (developed by GNOME)
• KDM (developed by KDE)
• wdm (using the WINGs widget set used in Window Maker)
• entrance (using the architecture used in Enlightenment v.17)

7.3 Widget toolkits and desktop environments

X provides "mechanism, not policy." As such, it does not specify or provide the user interface features, such as buttons, menus, window title bars and so on. These are provided by user software, such as window managers, GUI widget toolkits and desktop environments.

Early GUI toolkits for X included:

• Xaw (the Athena Widget Set)
• OLIT (OPEN LOOK Intrinsics Toolkit)
• XView
• Motif
• Tk

OLIT and XView function as the base toolkits for AT&T and Sun's OPEN LOOK GUI.

Motif provides the base toolkit for the Common Desktop Environment (CDE), which is the standard desktop environment used on commercial Unix systems such as Solaris and HP-UX. ( GNOME is offered in Solaris 9 and will be standard in future versions.)

Within the last few years, other toolkits have grabbed developer and user mind share. The modern toolkits include:

• Qt (used by KDE, developed by TrollTech)
• GTK+ ( GIMP Tool Kit, used by GNOME)
• wxWidgets
• fltk
• FOX

The KDE and GNOME desktop environments provide much better application functionality and services than is offered by plain window managers or older desktop environments.

7.4 Color modes of the X Window System

The colors used in X Window Systems sometimes confuse users, as old or special-purpose applications may require a certain color mode. Most modern applications use a color mode called "TrueColor", but historically X has supported several different modes:

• DirectColor
• GrayScale
• PseudoColor ( Chunky)
• StaticColor
• StaticGray
• TrueColor

See also: X11 color names.

8 Release history

Version	Release date	Most important changes
X1	June 1984	First time the software called X; fundamental changes were made that distinguished it from W.
X6	January 1985
X9	September 1985
X10	1985
X10R3		First release outside MIT.
X10R4
X11	September 1987	First release of the current protocol.
X11R2	January 1988	First X Consortium release. [3]
X11R3	October 25, 1988
X11R4	December 22, 1989	Application improvements, new fonts.
X11R5	1991	X386
X11R6	1994
X11R6.3 (Broadway)	December 23, 1996	Last X Consortium release.
X11R6.4	March 31, 1998
X11R6.5.1	August 20, 2000
X11R6.6	April 4, 2001	Bug fixes, XFree86 changes.
X11R6.7.0	April 6, 2004	First X.Org Foundation release, incorporating XFree86 4.4rc2.
X11R6.8.0	September 8, 2004	Window translucency, XDamage, Distributed Multihead X, XFixes, Composite, XEvIE

9 See also

• History of the graphical user interface

10 External links

• X.Org Foundation (official home page)
• An Introduction to X11 User Interfaces
• Introduction to X Windows
• The X Windows Disaster ( UNIX-HATERS Handbook)
• On the Thesis that X is Big/Bloated/Obsolete and Should Be Replaced (Christopher B. Browne)

10.1 Notable implementations

• XOrg Foundation Open Source Public Implementation of X11 — the official reference implementation
• XFree86 — at one time the most popular version, particularly on open-source Unix-like platforms
• X11 for Mac OS X — Apple proprietary X server, closely integrated with Mac OS X

X Window System

<Hide>