Misplaced Pages

Revision as of 14:03, 27 January 2005

In computing, the X Window System (commonly X11 or X) is a windowing system for bitmap displays. It is the standard graphical interface on Unix, Unix-like operating systems and OpenVMS, and is available for most other modern operating systems.

X provides the basic framework for a graphical user interface (GUI) environment: drawing and moving windows on the screen and interacting with a mouse and keyboard. X does not mandate the user interface — this is handled by individual programs. As such, the visual styling of X-based environments varies greatly; different programs may present radically different interfaces.

X features network transparency: the machine where application programs (the client applications) run need not be the user's local machine (the display server). X's usage of the terms "client" and "server" is the reverse of what people often expect, in that the "server" is the user's local display rather than the remote machine.

X originated at MIT in 1984. The current protocol version, X11, was released in September 1987. The project is now led by the X.Org Foundation; the current reference implementation is version 11 release 6.8.1 and is free software under the MIT License and similar permissive licenses.

The X client-server model and network transparency

Main article: X Window System protocols and architecture

X is based on a client-server model. An X server program runs on a computer with a graphical display and communicates with various client programs. The server accepts requests for graphical output (windows) and sends back 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 by tunneling the connection over an encrypted connection.

To start a remote client program displaying to a local server, the user will typically open a terminal window and telnet or ssh to the remote machine, tell it to display to the user's machine (e.g. export DISPLAY=:0 on a remote machine running bash) then start the client. The client will then connect to the local server and the remote application will display to the local screen and be controlled by the local mouse and keyboard. Alternately, some applications connect to a remote machine and start a client running there themselves.

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

Design principles of X

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

• 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. (Scheifler/Gettys 1996)

User interfaces

X deliberately contains no specification as to application user interface, 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. As such, the "typical" X interface has varied tremendously over the years.

A window manager is used to control the placement and appearance of application windows. This have an interface like that of Windows or the Macintosh (e.g. kwm in KDE or Sawfish in GNOME) or have completely different controls (e.g. twm, the window manager supplied with X). The window manager may be bare-bones (e.g. twm) or offer functionality verging on that of a full desktop environment (e.g. Enlightenment).

Most users use X with a full desktop environment, which includes a window manager, various applications and a consistent interface. The most popular are GNOME and KDE. 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.

Implementations

The canonical implementation of X is the X.Org reference implementation. Due to the liberal licensing, a number of variations, both free and proprietary, have appeared. Commercial Unix vendors have tended to take the reference implementation and adapt it for their hardware, usually customising it heavily and adding proprietary extensions.

Up to 2004, the most common X variant on free Unix-like systems was XFree86. This originated from the X386 server for IBM PC compatibles included with X11R5, hence the name. For many years, this project was the greatest source of technical innovation in X. 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 CDE, 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.

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 terminal 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 (the local broadcast domain) using the X Display Manager Control Protocol to generate a list of available hosts that they can run clients from. The initial host needs to be running an X display manager.

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.

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 Mac OS (versions 1 to 9) or Windows. In the early days, 8 to 16MB 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, Windows and Mac OS X Quartz have internal subsystem separation similar to the client/server divide in X and comparable resource usage.

X deliberately contains no specification as to user interface 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 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 . Consistency of application look and feel and communication is now generally addressed by programming to a desktop environment, which also avoids 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.

The X server usually manipulates the video hardware directly. If the server crashes, this can leave the video hardware in an unusable state. This originated with the X developers not having necessarily had access to the operating system kernel.

X does not include good network-transparent sound. As users increasingly expect sound, this has led to various incompatible sound subsystems. Most programmers in the past chose to ignore the network issue and simply use local, OS-specific sound APIs. The first generation of client-server sound systems included rplay and Network Audio System. More recent efforts have produced ESD (GNOME) and ARts (KDE), although these are by no means standard. Another system, Media Application Server, is in development.

X does not include a good solution to printing what you see on the screen. Most X clients print to PostScript entirely separately from what they send to the server. X11R6.3 included a failed attempt at a printing extension; Xprint is a current project to create a usable print extension.

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. There are also workarounds such as x11vnc, which makes an X server screen available via VNC.

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

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. These alternatives have seen negligible adoption, however, and the viability of any replacement that is not backwards-compatible with X is widely doubted.

Other competitors attempt to avoid the overhead of X by working directly with the hardware. Such projects include DirectFB. These efforts may be made superfluous by the Direct Rendering Infrastructure, which aims to provide a reliable kernel-level interface to the frame buffer.

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).

History

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. W used a network protocol supporting terminal and graphics windows, the server maintaining display lists.

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 (LCS). 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 being developed in the Andrew Project was not available for licensing and no alternatives were available.

The project solved this by creating a protocol that could run local applications and was able to call on remote resources. An initial Unix port of W in mid-1983 ran at one-fifth the 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 was the first window system environment that was truly hardware and vendor independent.

Scheifler, Gettys and Ron Newman set to work and X progressed rapidly. Version 6 was released in January 1985. DEC was preparing to release its first Digital UNIX workstation, and X was the only windowing system likely to be ready in time. X6 was ported to DEC's QVSS display on MicroVAX.

Color support was added in Q2 1985 to support the DEC VAXstation-II/GPX, forming what became version 9. Although MIT had licensed X6 to some outside groups for a fee, it was decided at this time to license X9 and future versions under what became known as the MIT License. X9 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 in late 1985. By 1986, outside organizations were asking for X. X10R2 was released in January 1986. X10R3 was released in February 1986 and was the first version to achieve wide deployment, with both DEC and Hewlett-Packard releasing products based on it. Other groups ported X10 to Apollo or Sun workstations and even the IBM PC/AT. X10R4 was the last version of X10, released in December 1986.

Although X10 was interesting and powerful, it had become obvious that a more hardware-neutral redesign of the X protocol was desirable before it was too widely deployed; but the scale of such a complete redesign was beyond the resources available at MIT alone. As it happened, DEC's Western Software Laboratory was between projects. Smokey Wallace of DEC WSL and Jim Gettys proposed that X11 be built at DEC WSL and made freely available under the same terms as X9 and X10. It was started in May 1986. The protocol was finalised in August. Alpha testing of the software started in February 1987, beta testing in May and X11 was finallly released on September 15, 1987.

The X11 protocol design was led by 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.

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 a neutral atmosphere inclusive of commercial and educational interests, with Scheifler as director. 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 revision, X11R6.3.

The Open Group

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 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.

X.Org and XFree86

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 was moribund . Most technical innovation was happening in the XFree86 project. In 1999, XFree86 joined X.Org as an honorary (non-paying) member , encouraged by various hardware companies interested in its use with Linux and its status as the most popular version of X.

By 2003, while Linux's popularity, and hence the installed base of X, surged, X.Org was all but inactive and active development was largely carried out by XFree86. However, there was considerable dissent within XFree86. It was perceived as far too cathedral-like in its development model; developers were unable to get CVS commit access and vendors had to maintain extensive patches . In March, long-term contributor Keith Packard was ejected with considerable ill-feeling .

X.Org and XFree86 began discussing a reorganisation suited to properly nurturing the development of X . Jim Gettys had been pushing strongly for an open development model since at least 2000 . Gettys, Packard and several others began discussing in detail what was needed for the effective governance of X with open development.

Finally, in an echo of the X11R6.4 licensing dispute, XFree86 released version 4.4 under a more restricted license which many projects relying on X found unacceptable , particularly as it was held to be incompatible with the GNU General Public License. This caused great controversy, and many considered the time was ripe for a fork .

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 was led by software developers and used community development on the bazaar model, which relies on outside involvement. Membership was opened to individuals, with corporate membership being in the form of sponsorship. X.Org also started working very closely with freedesktop.org.

The Foundation released X11R6.7 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, brought many of the old XFree86 developers on board.

X11R6.8 was released 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. Policy for the visual appearance is provided by external applications called compositing managers.

Future directions

With the X.Org Foundation and freedesktop.org, X development is progressing rapidly once more. 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.

Hardware manipulation is being moved to the kernel, with the video hardware being accessed only via OpenGL and the Direct Rendering Infrastructure module, introduced in XFree86 version 4 and present in X11R6.7 and later . The architecture of the reference implementation is also being separated into independent modules that can each be run as separate projects.

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.

Release history

See also

• History of the graphical user interface

References

• Robert W. Scheifler and James Gettys: X Window System: Core and extension protocols: X version 11, releases 6 and 6.1, Digital Press 1996, ISBN 1-55558-148-X
• An Introduction to X11 User Interfaces
• Lessons Learned about Open Source (Jim Gettys, USENIX 2000 talk on the history of X)
• On the Thesis that X is Big/Bloated/Obsolete and Should Be Replaced (Christopher B. Browne)
• The means to an X for Linux: an interview with David Dawes from XFree86.org (Matthew Arnison, CAT TV, June 1999)

External links

• X.Org Foundation (official home page)
• The X Windows Disaster (UNIX-HATERS Handbook)

Notable implementations

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

• X Window System