X Window System

Screen server: X-server or Wayland composer

X Window System in GNOME 2.20.

X Window System Logo

Logo of X.Org

The X Window System (in English, X Window System) is a window system, common in UNIX-like operating systems, which was developed in the mid-1990s. the 1980s at MIT to provide a graphical interface to Unix systems. This protocol allows graphic network interaction between a user and one or more computers, making the network transparent to the user. It generally refers to version 11 of this protocol, X11, which is currently in use. X is in charge of displaying graphic information completely independent of the operating system.

X was designed primarily to implement thin clients, where many people simultaneously used the processing power of the same computer working time-sharing. Each person used a networked terminal that had limited capabilities to draw the screen and accept user input. Due to the ubiquity of support for X software on Unix, it is used on personal computers even when there is no need for timesharing.

The X Window System distributes application processing by specifying client-server bindings. The server provides services to access the screen, keyboard and mouse, while the clients are the applications that use these resources for user interaction. In this way while the server is running locally, applications can be run remotely from other machines, thus providing the concept of network transparency.

Due to this client-server schema, X can be said to behave like a virtual graphical terminal.

The fact that there is a defined standard for X allows X servers to be developed for different operating systems and platforms, which makes the code very portable. For example, it allows you to have X clients running on a powerful UNIX server while the results are viewed on a desktop PC running any other operating system.

The communication between the X client and the server is done through a protocol known as Xprotocol, which consists of a series of bytes interpreted as basic commands to generate windows, position them, or control events. X clients access the Xprotocol through the use of a library called Xlib, which saves the X client programmer having to deal with the Xprotocol binary. However, window decoration and window handling aspects are not defined in this library.

X is not a window manager, it needs one to control window handling. This has the advantage that it allows the user to install one or more window managers of his choice. It also brings the advantage that it makes X strictly a graphics system, so that an X client could be sending a graphic to a screen, a printer, or any other hardware without realizing it, making graphical output more flexible.

On the other hand, the disadvantage of not having a single graphical environment is that X client programmers who want to make use of graphical environment resources (buttons, sliders, etc.) must choose a specific graphical environment to program and count that the user has at least the libraries of said graphical environment installed. The libraries of the graphical environments are known as "Toolkits", the X standard provides only a set of basic tools called Xintrisics that allow the programmers of the graphical environments to build their Toolkits about these.

Design

X uses the client-server model: an X server communicates with various client programs. The server accepts requests for graphical output (windows) and returns user input (from the keyboard, mouse, or touch screen). The server can work like this:

• An application displaying towards 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 terminal being the server and the applications being the clients - often confuses new X users, because the terms seem reversed. But X takes the perspective of the application, rather than that of the end user: X provides screen display and input/output services to applications, so it is a server; the applications use these services, therefore they are the clients.

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

An X client can emulate an X server by providing display services to other clients. This is known as "X nesting" (nested X). Open source clients such as Xnest and Xephyr support X nesting.

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

• In the local machine, a terminal window is opened.
• Use telnet or ssh to connect to the remote machine.
• Request local display/entry service (e.g. export DISPLAY=[user's machine]:0 if SSH is not being used with X tunneling enabled).

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

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

Practical examples of remote clients include:

• Manage a remote machine graphically.
• Running an intensive computing simulation on a remote Unix machine and displaying the results per screen on a Windows desktop.
• Run graphic software on several machines at the same time, controlled by a single screen, keyboard and mouse.

https://www.youtube.com/watch?v=mCdA4bJAGGk

Principles

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

• Do not add new functionality unless an implementer cannot complete a real application without it.
• It's so important to decide what the system isn't, like deciding what it is. Do not respond to the needs of everyone; instead, make the system extensive so that additional needs can be met in an upwardly compatible manner.
• The only thing worse than generalizing from an example is to generalize from any example at all.
• If a problem is not fully understood, it is probably best not to provide any solution at all.
• If you can get 90 percent of the desired effect for 10 percent of the work, use the simplest solution. (Seeing also worse is better).
• Insulate complexity as much as possible.
• Provide a mechanism instead of a policy. In particular, put the policy interface into the hands of customers.

The first principle was modified during the design of X11: "Don't add new functionality unless you know of a real application that requires it".

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

User interfaces

Graphical user interface of GNOME.

KDE 4 desktop environment.

Xfce graphical user interface.

X is primarily a definition of protocol and graphics primitives, and deliberately does not contain user interface design specifications, such as button, menu, and title bar styles for windows. 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 various desktop environments have been popular with users.

A window handle controls the placement and appearance of application windows. This can result in interfaces resembling those of Microsoft Windows or Macintosh (examples include Metacity in GNOME, KWin in KDE, Xfwm in Xfce, or Compiz) or having radically different controls (such as tiling window managers, like wmii or Ratpoison). Window managers range in sophistication and complexity from the simplest (eg, twm, the basic window manager supplied with X, or evilwm, an extremely lightweight window manager) to the most complete desktop environments such as Enlightenment.

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

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

Implementations

The X.Org implementation is the canonical implementation of X. Due to the type of free license, a number of variations have appeared, both free and proprietary. Commercial UNIX vendors have tended to take the open source implementation and adapt it for their hardware, usually by customizing it and adding proprietary extensions.

Until 2004, XFree86 provided the most common variant of X on free UNIX-like systems. XFree86 began a port of X for 386-compatible PCs, and, by the late 1990s, had become the largest source of technical innovation in X and the de facto standard of X development. Since 2004, however, the X.Org Server, a fork of XFree86, has become mainstream.

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, as its standard desktop environment, a version of X with the CDE known as DECwindows. Apple's Mac OS X v10.3 (Panther) and Mac OS X v10.4 (Tiger) include X11.app, based on XFree86 4.3 and X11R6.6, with better Mac OS X integration, in the Mac OS X v10.5 (Leopard) X.org Apple included X.org (X11R7.2 Codebase) instead of XFree86 (X11R6.8). Third-party servers under Mac OS 7, 8, and 9 included White Pine Software's eXodus and Apple's MacX.

Microsoft Windows is not shipped with X support, but there are many third-party implementations, both free software such as Cygwin/X, Xming, and WeirdX; as well as proprietary products such as Xmanager, Exceed, MKS X/Server, Reflection X, and X-Win32.

When an operating system with a native window system hosts X, additionally, the X system may or may not use its own desktop in a separate host window or it may run rootless, meaning that the X desktop is hidden and the window host environment manages the geometry and appearance of windows hosted on the host screen.

X Terminals

A network computer device, Network Computing Devices (NCD), terminal X NCD-88k

An X terminal is a thin client that only runs an X server. This architecture became popular for building cheap terminal packages so that many users could simultaneously use the same large computer server to run application programs as clients of each terminal X. This usage is very close to the original intention of the MIT project.

X terminals scan 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 must be running an X display manager.

Dedicated hardware for X terminals has become less common; a PC or a modern thin client running an X server typically provides the same functionality at the same or lower cost.

History

Predecessors

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

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

X derives its name as a successor to a pre-1983 window system called W (preceding the letter X in the English alphabet). The W Window System ran under the V operating system. W used a network protocol supporting terminals and graphics windows, the server maintained the list of screens.

Origin and early development

The original idea for X emerged at MIT in 1984 as a collaboration between Jim Gettys (of Project Athena) and Bob Scheifler (of the MIT Computer Science and Artificial Intelligence Laboratory). Scheifler needed a usable display environment to debug 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, required a platform-independent graphics system to link together heterogeneous systems from multiple vendors; the window system, then under development at the Andrew Project of Carnegie Mellon University made no licenses available, and no alternatives existed.

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

Scheifler, Gettys and Ron Newman worked together and X made rapid progress. They released Version 6 in January 1985. DEC, then preparing to release the Ultrix workstation, judged X to be the only window system environment likely to be available in time. DEC engineers ported the X6 to DEC's QVSS display on the MicroVAX.

In the second quarter of 1985, X acquired color support to run on 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 reading unaligned data on the RT forced an incompatible change to the protocol, leading to version 10 in late 1985. By 1986, outside organizations had begun ordering the X. The release of the X10R2 occurred in January 1986; that of the X10R3 in February 1986. Although MIT had licensed the X6 for free to some outside groups, at that time it decided to license the X10R3 and future versions under what has since been known as the MIT license, attempting to popularize X further. and in return, hoping that many more apps would become available. The X10R3 became the first version to achieve wide deployment, with both DEC and Hewlett-Packard releasing products based on it. Other groups ported the X10 to Apollo Computer and Sun workstations and even to the IBM AT. Demonstrations of the first commercial application for X took place at the Autofact trade fair of that time. It was a mechanical engineering computer-aided design system from Cognition Inc. that ran on VAXes and displayed the image on PCs running an X server. The latest version of the X10, the X10R4, appeared in December 1986.

Attempts were made to enable X servers as real-time collaboration devices, much like 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 some interesting and powerful functionality, it had become obvious that the X protocol could have a more hardware-neutral design before it became too widely adopted; but MIT alone would not have the resources available for such a complete redesign. While this was happening, DEC's Western Software Laboratory (WSL) found itself between projects with an experienced team. The WSL's Smokey Wallace and Jim Gettys proposed that the DEC WSL build the X11 and make it freely available under the same terms as the X9 and X10. This process began in May 1986, with the protocol concluded in August. alpha testing of the software began in February 1987, beta testing in May; the release of the X11 finally happened on September 15, 1987.

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

The MIT X Consortium and the X Consortium, Inc.

X Window System, a historic example of the graphical user interface and common applications the distribution of the MIT X Consortium running under the twm window handler: X Terminal, Xbiff, xload and a graphic browser of manual pages, Man page.

In 1987, with the success of X11 evident, MIT wanted to give up management of X, but in a June 1987 meeting with nine vendors, the vendors told MIT that they believed in the need for an entity neutral to prevent X from fragmenting in the market. In January 1988, the MIT X Consortium was formed as a non-profit group of vendors, 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, sources, window managers, and utilities; and Keith redeployed 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's Athena project. The MIT X Consortium produced several significant revisions of X11, the first (Release 2 - X11R2) in February 1988. Ralph Mor and Jay Hersh later joined the team. In 1993, as the MIT X Consortium prepared to leave MIT, the team was joined by R. Gary Cutbill, Kaleb Keithley, and David Wiggins.

In 1993, the X Consortium, Inc. (a non-profit corporation) was formed as the successor to the MIT X Consortium. He released X11R6 on May 16, 1994. In 1995 he took over development of the Motif toolkit and the Common Desktop Environment from Unix systems. The X Consortium disbanded in late 1996, producing a final revision, the X11R6.3, and a legacy of increasing commercial influence on development.

The Open Group

In January 1997 the X Consortium handed over management of X to The Open Group, a group of vendors formed in early 1996 by the merger of the Open Software Foundation with X/Open.

The Open Group released X11R6.4 in early 1998. Controversially, X11R6.4 departed from traditional liberal licensing terms, as The Open Group attempted to secure funding for X development. The new terms would have prevented its adoption by many projects (such as XFree86) and even by some commercial vendors. After XFree86 appeared to be evaluating a fork, The Open Group relicensed X11R6.4 under the traditional license in September 1998. The last release from The Open Group came as X11R6.4 patch 3.

X.Org and XFree86

XFree86 originated in 1992 from the X386 server for IBM PC compatible systems 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 a port of X, to the leading and most popular implementation and became the de facto manager of X development.

In May 1999, The Open Group formed X.Org. X.Org oversaw the release of versions X11R6.5.1 onwards. At that point, X development became moribund; most of the technical innovation since the X Consortion had disbanded was taking place in the XFree86 project. In 1999, the XFree86 team joined X.Org as an honorary (non-paid) member, encouraged by various companies interested in using XFree86 with Linux and its status as the most popular version of X.

By 2003, the popularity of Linux (and thus the installed base of X) arose, X.Org remained dormant, and active development took place on XFree86. However, there was considerable splinter development within XFree86. The XFree86 project suffered from a perception as too cathedral-like a development model; developers could not have CVS commit access and vendors had to maintain an extensive set of patches. In March 2003 the CFree86 organization ousted Keith Packard, who had joined XFree86 after the end of the original MIT X Consortium., with considerable discomfort.

X.Org and XFree86 began discussing a reorganization aimed at properly nurturing X development. Jim Gettys had been a strong pusher for an open development model since at least 2000. Gettys, Packard and several others began to discuss 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 that made many projects that relied on X find it unacceptable. license was based on the original clause published by the BSD license, which was seen by the Free Software Foundation and Debian as incompatible with the GNU General Public License. Other groups saw later restrictions as being against the original spirit of X (OpenBSD threatening with a fork, for example). The license issue, combined with the difficulties of having the changes, left many feeling the time was ripe for a fork.

X.Org Foundation

In early 2004, people from X.Org and freedesktop.org formed the X.Org Foundation, and were given control of the X.org domain name by the Open Group. This marked a radical change in the governance of X. Since the administrators of X since 1988 (including the previous X.Org) had been vendor organizations. The foundation was now led by software developers and used a development community based on the bazaar model, which relied on outside involvement. Membership was open to individuals, with corporate members being in the form of patrons. Some large corporations like Hewlett-Packard and Sun Microsystems currently support the X.Org Foundation.

The foundation takes an inadvertent role over the development of X: technical decisions are made on their merits by reaching a broad consensus among members of the community. Technical decisions are not made by the board of directors; in this sense, it is heavily modeled by the technical non-interventionism of the GNOME Foundation. The foundation does not employ any developers.

The foundation released X11R6.7, the X.Org Server, in April 2004, based on XFree86 4.4RC2 with the changes from X11R6.6 combined. Gettys and Packard had taken the latest version of XFree86 under the old license, making a point of an open development model and retaining GPL compatibility, brought many of the old developers on board.

X11R6.8 came in September 2004. It added a significant number of features, including preliminary support for translucent windows and other fancy visual effects, magnifying glass for the screen, thumbnailers, and facilities for integrate 3D immersive display systems such as Sun's Looking Glass Project and the Croquet Project. External applications called window composition handlers provide policies for the visual appearance.

On December 21, 2005, X.Org released X11R6.9, the monolithic free source for legacy users, and X11R7.0, the same source code separated into independent modules, each maintained in separate projects. The foundation released X11R7.1 on May 22, 2006, about four months after 7.0, with considerable feature improvements.

Version history

Future versions