|
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. Unlike
contemporaries such as Microsoft Windows, X does not mandate the
user interface itself — this is handled by individual programs.
The visual styling of X-based environments therefore varies greatly; different programs may present radically different
interfaces.
X features network transparency: the machine where application programs (the clients) 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 version, X11, was released in 1987.
The project is now led by the X.Org Foundation; the current
reference implementation is version 11 release
6.7.0.
KDE 3.1
GNOME 2
CDE on Solaris 8
DECwindows CDE on OpenVMS 7.3-1
Architecture
X is based on a client-server model. A display server program
runs on a computer with a graphical display and communicates with various client programs, accepting requests for
graphical output (windows) and sending 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 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.
Implementations
The canonical implementation of X is the X.Org reference implementation. This is available under the
open source MIT License
and similar 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.
The X variant most common on free Unix-like systems is XFree86. This originated from the X386 server included with the reference implementation, hence the name. The other 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 for platforms with their own graphical environments, such as
Windows, Mac
OS/MacOS X and OS/2. X servers used on
Windows include Cygwin/X, Exceed,
XVision, X-Win32 and WeirdX. 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.
Hewlett-Packard's OpenVMS operating system includes a version of X with the CDE desktop, known as
DECwindows, as its standard desktop
environment.
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.
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 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, 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. 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.
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 often for Windows (the
largest consumer market) first.
X has never included support for sound. As users increasingly expect sound, this has led to various incompatible sound
subsystems. Most programs in the past have chosen to ignore the issue of network sound and simply use local, OS-specific sound
APIs. This works fine for workstation systems, but does not provide a mechanism for X-style
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 that will be part of or more closely linked 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.
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.
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
Origin and early development
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.
X was initially conceived at MIT in 1984 as part of Project Athena, a joint effort between the MIT Laboratory for Computer Science and Digital Equipment Corporation to provide easy
access to computing resources for all students and make the existing assortment of incompatible workstations from different vendors work together. Because MIT could not buy all the workstations needed
and no single vendor appeared willing to donate them, the Institute needed a platform-independent graphics system to link
together its heterogeneous systems.
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 May 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 operating 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 version 7.
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
The protocol design for X11 was proposed by Smokey Wallace of DEC's DECWSL and Jim Gettys. It was
started in May 1986 and released in 1987.
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.
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, preventing its adoption by many projects (such as XFree86) and even some commercial
vendors. To avoid 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.
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.
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.
Technical details
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:
- Request: The client requests an action or information.
- Reply: The server responds. Note that not all requests generate replies.
- Event: The server sends an event to the client, e.g. keyboard or mouse input, or a window being
moved, resized or exposed.
- 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.
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:
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 five years, other toolkits have grabbed developer and user mind share. The modern toolkits include:
The KDE and GNOME desktop environments provide
much better application functionality and services than is offered by plain window managers or older desktop environments.
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.
See also
External links
Notable implementations
|