Unix GUI
Guntis Barzdins
Girts Folkmanis
GUI History
 In 1962, Douglas Engelbart invented the
first “mouse,” which he called an “X-Y
Position Indicator.”
 It was a little gizmo housed in a wooden
box on wheels that moved around the
desktop and took the cursor with it on
the display.
Source: US Patent Office
GUI History
 In 1963 a grad student at MIT,
Ivan Sutherland, submitted as
his thesis a program called
“Sketchpad.” This was the first
GUI (Graphical User
Interface) long before the term
was coined."
http://accad.osu.edu/~waynec/history/images/ivan-sutherland.jpg
GUI History
 In the 1970s, at Xerox’s
PARC facility, Alan Keys
created an object-oriented
graphical programming
language called “Smalltalk.”
Smalltalk featured a graphical
user interface (GUI) that
looked suspiciously similar to
later iterations from both
Apple and Microsoft.
http://www.sra.co.jp/people/aoki/SqueakIdioms/chapter01/Xerox1100SIP.jpg
GUI History
 1981, Xerox attempted to market the
“Star.” It introduced the idea of what
you see is what you get
(WYSIWYG).
 Commercial failure

cost ($15,000);


limited functionality


3rd party vendors could not add
applications
perceived as slow


e.g., no spreadsheet
closed architecture,


IBM had just announced a less
expensive machine
but really fast!
slavish adherence to direct
manipulation
http://www.catb.org/~esr/writings/taouu/html/graphics/xerox_star.jpg
Apple gets a GUI
 In 1983, the Apple Lisa was
first GUI offering.
Apple II,
1980
http://www.s-line.de/homepages/horber-privat/bilder/apple2a.jpg
Lisa
http://fp3.antelecom.net/gcifu/applemuseum/lisa2.html
Apple gets a GUI
http://computermuseum.50megs.com/images/collection/apple-mac-plus.jpg
 In 1984, Macintosh was the first
computer with a GUI marketed to the
masses.

“old ideas” but well done!
 Commercial success because:


aggressive pricing ($2500)
did not need to trail blaze






learned from mistakes of Lisa and
corrected them; ideas now “mature”
market now ready for them
developer’s toolkit encouraged 3rd party
non-Apple software
interface guidelines encouraged
consistency between applications
domination in desktop publishing
because of affordable laser printer
and excellent graphics
Full Microsoft Office suite
(Apple was the dominant player at this
time.)
http://toastytech.com/guis/bigmac1.gif
Microsoft Gets a GUI
 Microsoft introduced Windows
1.0 in 1985

Tiled Windows, no overlapping
 Windows 2.03 in 1987

Overlapping windows
 Windows 3.0 in 1990

Features Program Manager
Windows Timeline
 It took roughly 15 years to
consolidate its shell-based
GUI architecture offerings with
its embedded GUI
architecture offerings.
http://www.microsoft.com/windows/WinHistoryProGraphic.mspx
Unix Gets a GUI
 The X Windows System was introduced
in the mid-1980s to provide graphical
support for unix operating systems.
 The implementation was a client-server
approach, where an X window system
server ran on the displaying machine,
and the client programs communicated
with it using a network protocol.
 X provides only a communication
mechanism, not policy. At least three
major user interface look & feel styles
are widely used on X - MIT's own Athena
style, Sun and AT&T's OpenLook, and
OSF's Motif (supported primarily by HP
and IBM).
http://www.pattosoft.com.au/jason/Articles/HistoryOfComputers/X11.gif
Exceptions: MacOS X uses a proprietary Aqua
windowing system (more efficient than X11), mobile phone
interfaces
Topics
 X Windows






X Protocol
Classic X apps
Starting X apps
Window managers
Desktop environments
Desktop applications
X Window
 The X Window system was developed as part of
Project Athena at MIT. In 1987, X Version 11 is
released. X is now controlled and maintained by the
Open Group.
 The X Windows System, also referred to as ‘X’ or
“X11”, is the standard graphical engine for Unix and
Linux.
 It is largely OS and hardware independent, it is
network-transparent, and it supports many different
desktops.
The Graphic User Interface in X
 X Window uses a bit-mapped display where each pixel
can be manipulated individually.
 The entire display is known as the root window, and
individual applications are displayed as windows on this
root window.
 X is started with the startx or xinit commands.

X can also be invoked during system startup
X Protocol
The X Protocol provides a client-server architecture at
the application level:
The X client is the processing part of the application
and often runs on a remote machine.
The X server is the display and interaction system.
X Protocol cont’d
The X Protocol is also divided into device dependent and
device independent layers.
X Server Design
 Device Dependent Layer




It is this layer that is responsible for localizing the X server to
the native environment, be it MS Windows or Solaris.
This layer swaps bytes of data from machines with differing
byte ordering. Byte ordering (MSB and LSB) is noted in each X
request.
This layer hides the architectural differences in hardware and
operating systems.
Maintains device driver dependencies for keyboard, mouse and
video.
Networked Windowing
 X Window designed to allow apps to run on
remote machines
 Uses client-server model
Network
X Server
std system software
User
Client
app software
X architecture
The client-server nature of the X Protocol allows a single X
server to support many clients (applications) on several hosts.
Client-Server Window System
Client Application
Programs
Application 1
Application 2
Application n
Virtual
display 1
Virtual
display 2
Virtual
display n
Server
Could be
Window
Manager
Resource
allocator
Device-independent abstraction level
Translates abstraction into reality:
one per terminal type
Devices
Keyboard Mouse
Device
driver
Window
1
Window
2
Window
n
(After Fig 10.2, Dix, Finlay,
Abowd and Beale)
X Protocol messages
Requests – client sends requests to the server (e.g. create window)
Replies – server response to client requests
Events – server forwards events (such as mouse clicks or keyboard
entry) to the client
Errors – server reports errors to the client
X Server
The X server therefore:
 displays drawing requests on the screen.
 replies to information requests.
 reports an error in a request.
 Manages the keyboard, mouse and display device.

Multiplexes keyboard and mouse input onto the network (or via
local IPC) to the respective X clients. (X events)
 creates, maps and destroys windows.

writes and draws in windows
X Client
 sends requests to the server.
 receives events from server.
 receives errors from the server
Protocol Messages
Requests
 X clients make requests to the X server for a
certain action to take place. i.e.: Create Window
 To enhance performance, the X client normally
does not expect nor wait for a response. The
request is typically left to the reliable network
layer to deliver.
Protocol Messages
Replies
 The X server will respond to certain X client
requests that require a reply. As noted, not all
requests require a reply.
Protocol Messages
Events
 The X server will forward to the X client an event
that the application is expecting. This could
include keyboard or mouse input. To minimize
network traffic, only expected events are sent to X
clients.
 X events are 32 bytes
Protocol Messages
Errors
 The X server will report errors in requests to the X
client. Errors are like an event but are handled
differently.
 X errors are the same size as events to simplify
their handling. They are sent to the error handling
routine of the X client.
X Windows Protocol Overview
X Windows is the predominate windowing system on UNIX computers, developed by the X Consortium, lead by M.I.T. An X server manages
the display on the workstation. Clients can connect to server via TCP/IP and perform graphics operations. This makes X Windows much
more network capable than Microsoft Windows, for example, which can only be accessed via a local API.
X Windows operates over TCP, typically using server port numbers starting with 6000. The X server for a system's first display listens on
port 6000; if the system has a second display, its server listens on port 6001; a third display would listen on 6002; etc. The protocol used
over this reliable stream connection is essentially request/reply, and it's reputation is as a fat protocol that consumes a lot of bandwidth.
Lightweight X (LWX), introduced in X11R6, attempts to reduces X's bandwidth needs to the point where it can be run over dialup modem
connections.
The X Protocol, documented in a postscript file, defines dozens of messages that can be exchanged between a client and a server. They
can generally be classified into four categories: Requests, Replies, Events, and Errors. Typical requests include Draw PolyLine, Draw Text,
Create Window, Fill. Replies are matched to particular Requests. Events are asynchronous occurances such as keystrokes and mouse
clicks. Errors are matched to particular Requests.
If a window is partially or fully obscured by another, overlapping window, the server has two options available to it. The server can allocate
additional memory, called backing store, to record to contents of the obscured window. This is purely optional, however. The server can
simply ignore the obscured part of the window. Later, when that part of the window becomes visible again, the server sends an Expose
event to the client, which must then redraw the affected area. The client, therefore, must be prepared to redraw any part of its windows at
any time.
Applications do not need to access the X Windows protocol directly. X Windows supports several APIs. The most basic of these is Xlib,
which interfaces fairly directly to the underlying network protocol. Most X client applications are linked against Xlib, which allows them to
operate on either a local or remote X server, simply by adjusting either an environment variable or a command-line argument.
Widgets layer on top of Xlib and provide X Windows with an object-oriented programming model. A widget is an X window capable of
handling most of its own protocol interaction. The most popular widget sets are Athena Widgets (aw) and Motif.
X Window's security model is all-or-nothing. Either an application can perform any operation on an X desktop, or it can perform none. There
is no concept of limiting an application to a single top-level window, for example. Although there is power in this model, such as allowing the
window manager to be a normal X client, there are also serious security implications. A hostile X client could connect to an X server and
arrange to capture any screen image, or even to capture keystrokes as a password is being typing in one of the windows. For this reasons,
X servers are typically fairly restrictive about which clients they will accept connections from. Two major security models are available. Hostbased security (traditionally controlled by the xhost program), permits or denies connections based on their source IP addresses.
Authentication (traditionally controlled by the xauth program), requires the connecting program to possess a secret password , typically
stored in a UNIX file and subject to standard UNIX access controls. Kerberos-based authentication is also available.
Starting X Windows
On a local PC or workstation, you can usually start the
X server with the “xinit” (“startx”) command or it may
be started automatically by “xdm” (graphical login
display).
Configuration stored in /etc/XF86Config
Usually edited with utility /usr/X11R6/bin/xf86config
or /usr/X11R6/bin/xf86cfg
xf86cfg
Configuring X Windows
 mouseconfig

Command used to configure a mouse for use by X
Windows
 xconfigurator


A program that is used to configure video adapter
card and monitor information for use by X Windows
redhat-config-xfree86 used in recent
Red Hat & in Fedora
Configuring X Windows
 Fedora and X Windows configuration


Fedora has greatly improved video & monitor
detection
Not included in Fedora (Red Hat only):
SuperProbe
 Xf86config
 Xconfigurator

Starting X applications
To launch an X client from a remote host for display on the
local X server, you need to set two things:
1) Permission for the remote host to display X clients on the
local machine.
xhost +remotehost
2) The target display for the remote application.
setenv DISPLAY=server:display
[hostname]:displaynumber[.screennumber]
not needed,
if same host
“0” in most cases
defaults to “0”
/etc/X11/xinit/xinitrc (xinit)
or /home/g/.xsession (xdm)
#!/bin/sh
# $Id: xinitrc,v 1.2 2003/02/27 19:03:30 jharper Exp $
xrdb -load $HOME/.Xresources
xsetroot -solid gray &
xclock -g 50x50-0+0 -bw 0 &
xterm &
loads resources: default fonts,
colours, window sizes
# start the window manager
exec twm
xinit executes this script
last line: replaces shell-script with window
manager, will terminate all background
processes on exit
Shells
 Unix and DOS operating systems circa 1980s support text-based
user interfaces via a program called a shell. These shells insert
another layer between the user and the operating system. Typical
text shells under unix are csh and ksh. The typical text shell under
microsoft is command.com. It is still emulated today by cmd.exe.
 Original unix and Microsoft GUI support was also implemented as
shells. The dominant unix GUI library became an open library
called X11 supported by the X.org foundation. Microsoft
introduced Windows 1.0 as a shell that ran on a layer above MSDOS.
 The original Apple GUI is embedded into its operating system
kernel. Windows migrated to embedding GUI support beginning
with Windows NT.
Classic X11
[Guntis-Computer:/usr/X11R6/bin] guntis% ls
X
luit
xbiff
Xmark
makedepend
xcalc
Xnest
makeg
xclipboard
Xprt
makepsres
xclock
Xquartz
makestrs
xcmsdb
Xvfb
mergelib
xconsole
appres
mkcfm
xcursor-config
atobm
mkdirhier
xcutsel
bdftopcf
mkfontdir
xditview
bdftruncate
mkfontscale
xdm
beforelight
mkhtmlindex
xdpyinfo
bitmap
oclock
xedit
bmtoa
proxymngr
xev
ccmakedep
pswrap
xeyes
cleanlinks
quartz-wm
xfd
cxpm
resize
xfindproxy
dpsexec
revpath
xfontsel
dpsinfo
rman
xfs
dumpkeymap
rstart
xfsinfo
editres
rstartd
xft-config
fc-cache
sessreg
xfwp
fc-list
setxkbmap
xgamma
fontconfig-config
showfont
xgc
freetype-config
showrgb
xhost
fslsfonts
smproxy
xinit
fstobdf
startx
xkbbell
gccmakedep
sxpm
xkbcomp
glxgears
texteroids
xkbevd
glxinfo
twm
xkbprint
iceauth
ucs2any
xkbvleds
ico
uxterm
xkbwatch
imake
viewres
xkill
lbxproxy
x11perf
xload
listres
x11perfcomp
xlogo
lndir
xauth
xlsatoms
[Guntis-Computer:/usr/X11R6/bin] guntis% man xwud
xlsclients
xlsfonts
xmag
xman
xmessage
xmh
xmkmf
xmodmap
xon
xprop
xrandr
xrdb
xrefresh
xset
xsetmode
xsetpointer
xsetroot
xsm
xstdcmap
xterm
xtrapchar
xtrapin
xtrapinfo
xtrapout
xtrapproto
xtrapreset
xtrapstats
xvidtune
xvinfo
xwd
xwininfo
xwud
xterm
The most important X application is, rather ironically, the
terminal program xterm.
Old school xterm:
xterm: The Main Client
 You can invoke all UNIX commands and X programs form the
UNIX command line available in an xterm window.
 xterm can also be used with a scrollbar
(-sb), and the number of lines saved can be specified (-sl).
 You can position and specify the size and position of a window (geometry) and its foreground and background color
(-fg and -bg).
 You can start a program as an icon (-icon) and provide a name (name) or title (-title).
Some classic X apps
xclock – pretty self-explanatory
Some classic X apps
xeyes – ok, this is really the most important
xnest
XFree86
“In short, XFree86 is an open source X11-based
desktop infrastructure.” – xfree86.org
X.org Foundation – sucessor of XFree86
Used in most Linux distributions
Window managers,
Widget toolkits,
Desktop environments,
Desktop applications
X Architecture
1.
2.
3.
4.
5.
6.
The kernel gets an event from an input device
and sends it to X.
The X server determines which window the
event affects and sends it to the clients that
have selected for the event in question on that
window.
The client looks at the event and decides what
to do.
When the X server receives the rendering
request, it sends it to the driver to let it program
the hardware to do the rendering.
The damage event tells the compositor that
something changed in the window and that it
has to recomposite the part of the screen where
that window is visible.
The X server receives the rendering requests
from the compositor and either copies the
compositor back buffer to the front buffer or
does a pageflip.
X and the GUI
 X itself provides the back end needed
for a GUI. It doesn’t, however, provide
an interface itself.
 Window management functions – e.g.
moving or resizing windows – are
performed by a window manager,
which is itself an X client. These range
from the spartan (twm) to the complex
and graphically intensive
(Enlightenment).
 There are various different toolkits for
creating graphical applications,
providing libraries of widgets such as
buttons etc. These range from the old
and ugly (Motif) to the new and shiny
(GTK+, Qt)
 No two users can be assumed to have
the same window manager and
different applications can use different
toolkits (or even write their own).
Therefore, there’s a lack of consistency
about the average X desktop – this
makes things ugly and can be hard to
use.
Why not only a basic X11
environment?
 Most X11 applications have important shortcomings:
 Application Interoperability is too hard
 User Interface is inconsistent and of unequal quality
 Modern desktop environment brings the "glue"
 Drag & Drop, Session Management, etc...
 Consistent "look and feel"
 Unified Help System
 Easy dialog based desktop configuration
 Common application development framework (-> MFC)
 Compound document framework (-> OLE)
 New exciting possibilities:
 Hundreds of new applications (including Office)
 Powerful application development environment
Window managers
One can use X11 without a window manager.

Typically, one writes a session script which starts an "xterm" at a "-geometry" location.
One then starts other X11 clients by giving their "-geometry" explicitly, because there is
no window manager
The window manager is a special X client that controls the placement and movement
of applications, provides title bars and control buttons, menus and taskbars. Some
support virtual desktops and very fancy graphics.

When a window manager is running, some of interaction between the X server and its
clients is redirected through the window manager.
Classic window managers include:


TWM
MWM - Motif Window Manager
Nowadays, KDE (kwm) and GNOME (sawfish) are two widely used window managers
in Linux.
The Tab Window Manager (TWM)
Linux GUI Components
Graphical Programs (X clients)
Desktop Environment
Window Manager
X Windows
Video Adapter Card Hardware
Motif Window manager
and Widgets
KDE
 KDE is the traditional desktop environment
used on Linux systems
 K Windows Manager (kwm)

The window manager that works under the KDE
Desktop Environment
 Qt toolkit

Software toolkit used with the KDE Desktop
environment
Linux Developement
 Qt Class Library


C++
Cross Platform







Qt/Windows
Qt/X11 (Linux, Solaris, HPUX,
AIX, etc)
Qt/Mac
GPL – Free for non-commercial apps
Qt was used to build KDE
from Trolltech in Norway
www.trolltech.com
Gnome
 GNOME Desktop Environment


Default desktop environment in Red Hat Linux
Typically uses the Sawfish Window Manager and
the GTK+ toolkit for the C programming language

The GTK+ toolkit was originally developed for the
GNU Image Manipulation Program (GIMP)
 Ported also to MS Win, MacOS X planned
Bluecurve
 Bluecurve



Both a visual theme and a set of modifications to
the KDE and GNOME environments
Gives both a common “look & feel”
Smooths out inconsistent behaviors between the
different WMs
The KDE Desktop Environment
The Bluecurve + KDE in Fedora
The GNOME Desktop Environment
The Bluecurve + GNOME in Fedora
KDE and Gnome architectures
What is a desktop?
 It is the top of a desk
 It is a pc cabinet for the
desktop
 It is the graphical user
interface (GUI) on a pc
 It is the graphical enviroment
for the average user on a pc
KDE and GNOME
 K Desktop Environment


KDE is a "complete desktop environment that try to
make linux accessible to everybody"
At present KDE 3.5
 GNU Network Object Model Environment


AIM: "GNOME Intends to build a complete, userfriendly desktop, similar to CDE or KDE, but based
entirely on free software"
At present GNOME 2.14
KDE
http://www.kde.org/
KDE
GNOME
http://www.gnome.org/
Render Extension Shadows
Render Extension Translucency
Render Extension –
anti-alias font
SuperKaramba dynamic background info
More GUI on Linux
 X Window server
 Window Managers







KDE
GNOME
WindowMaker
FVWM
Enlightenment
IceWM
CorelLinux
WindowMaker
http://www.windowmaker.org/
FVWM
http://www.fvwm.org/
Enlightment
http://www.enlightenment.org/
IceWM
http://iceorg.sourceforge.net/
Corel Linux
http://linux.corel.com/
Office suites for Linux
 WordPerfect Office
 ApplixWare
 StarOffice
 GNOME Office
 KOffice
StarOffice / OpenOffice /
LibreOffice
 SUN Microsystems





Writer
Calc
Impress
Draw
Base
 Danish in june
 Free, not Open Source
KOffice
 KDE project





KWord
KSpread
Kpresenter
Killustrator
KChart
 Open Source
GNOME Office
 GNOME project





AbiWord
Gnumeric
GIMP
Dia
GNOME-DB
 Open Source
Other desktop applications
 GIMP



Image editor á la Adobe
Photoshop
Free and open
Thousands of plug-ins
 Mozilla


Webbrowser (Firefox)
Mailclient (Thunderbird)
Office Suites
SpreadSheet
Presentation
Vector Drawing
Word Processor
Chart Drawing
Formula Editor
Image Processor
Diagram Creation
Planning Events
Calendar
StarOffice
KDE
GNOME
MS Windows
StarCalc
StarImpress
StarDraw
StarWriter
StarChart
StarMath
StarImage
Kspread
Kpresenter
Killustrator
Kword
Kdiagramm
Kformula
Kimage
Gnumeric
Achtung
Gill
AbiWord
Guppi
Excel
PowerPoint
Paint
Word
Excel Graphic Feature
Equation Editor
Ms. Image
Visio
Gimp
Dia
StarSchedule
Korganizer Gcalendar
Using X windows remotely on
a MS-Windows machine.
 You need to get a program called an “Xserver”.
Exceed works well and is free for academic use.
Cygwin is another option.
 You must allow X-forwarding through your ssh
client. Putty is good for this.
X server security configuration
xhost
xhost simply allows you to specify which machines are, or aren't allowed to connect to the X server, this is a very
simplistic security mechanism and is not really suitable in any modern environment, however used in conjunction
with other mechanisms it can help. The command is quite simple: 'xhost +example.org' adds example.org, 'xhost example.org' removes example.org from the list, you must also specify 'xhost -' to turn on the access control list, or
else everyone is let in by default.
mkxauth
mkxauth is definitely a step up from xhost. mkxauth helps create ~/.Xauthority files, and merge them, which are used
to specify hostnames and the related magic cookies (basically a token used to gain access). These cookies can then
be used to gain access to a remote X host (you essentially have a copy of the cookie on each end) and are
transferred either plain text (insecure) or DES encrypted (quite secure). Using this method you can be relatively safe
and secure. Xauthority files can also be used in conjunction with Kerberos, removing the necessity to copy
Xauthority files around and keep them in synchronization. Hosts authenticate to each other through a central
Kerberos key server(s) in an encrypted fashion, this method is most appropriate for large installations/etc. mkxauth
has an excellent man page 'man mkxauth' and more generalized details are available in the Xsecurity man page (not
sure how common this name page is) 'man Xsecurity'.
SSH tunnel
SSH or OpenSSH can be used to create a tunnel between hosts (or more specifically between two X servers), thus
encrypting the channel, providing authentication, and generally making things safer. The following web page explains
it http://csociety.ecn.purdue.edu/~sigos/projects/ssh/forwarding/.
Mac OS X
Mac OS X Architecture
Apple’s Boiled Sweets diagram
http://developer.apple.com/macosx/architecture/
The Smartphone Platform
 With the iPhone being the first to the marketplace
it sets the configuration of the Smartphone
Platform








3G/4G connectivity
WiFi connectivity
Bluetooth connectivity
accelerometer w/compass
ambient light sensor
proximity sensor
GPS
gyroscope
What is iOS
 Apple’s mobile OS for phones (iPhone), tablets
(iPad), handhelds (iPod),
 based on BSD Unix
 Application programming done in Objective C
 Supports Bluetooth, Wi-Fi, and 3G and 4G
networking
Apple iOS
What is Android
 Android is an open source operating system,
created by Google specifically for use on mobile
devices (cell phones and tablets)
 Linux based (2.6 kernel)
 Can be programmed in C/C++ but most app
development is done in Java (Java access to C
Libraries via JNI (Java Native Interface))
 Supports Bluetooth, Wi-Fi, and 3G and 4G
networking
The Android Software Stack
Main GUI parts
Status Bar
Home Screen
App Screen
Favourites Tray
Navigation bar
(Android 3.0+)
Commonly Used Packages
User interface controls and widgets
User interface layout
Secure networking and web browsing
Structured storage and relational databases (SQLite
RDBMS)
 2D and 3D Graphics SGL and OpenGL
 Audio and visual media support
 Access to optional hardware (GPS)




Security
Semantic
Android Application
Development
Eclipse
IDE
Android
SDK
Android
Emulato
r
Android
Mobile
Device
iOS Application Development
XCODE
IDE
iOS
Simulat
or
iOS
SDK
iOS
Mobile
Device
Android development
Android
Manifest
Resourc
e XML
Java
Source
Generat
ed Class
Android
Libraries
Java
Compile
r
.dex
File
Dalvik
VM
iOS development
Xcode
Interface
Builder
Objectiv
eC
Source
.xib file
Foundation
Framework
Cocoa
Libraries
Objective
C
Compiler
.
Simulato
r or
Device
Sams Teach Yourself Android™Application Development in 24 Hours (0321673352)
FIGURE 5.6 Simplified Android platform architecture from a security perspective.
Copyright ©2010 Lauren Darcey and Shane Conder
UI With GUI Builder
Android Basics
•
•
•
•
Open source OS
•
Uses Linux kernel
•
Optimized for limited-resource environment
Apps typically written in Java
Apps run on the Dalvik Virtual Machine
•
Not a JVM, but works similarly from developer’s point of
view
•
Usually one app per DVM
•
Each DVM runs under Linux as a separate user
•
App permissions set at install time
Possible to use C or C++ compiled to machine code, but still runs on VM.
X11, X12, What next…
X12

X11 was defined in the middle of the 1980's. Since then, computers have changed almost beyond
recognition; the simple framebuffer model used by computers at the time has been replaced
programmable graphics hardware that is both complex and powerful. Not only has graphics hardware
changed, but the basic processing model has and continues to change; parallelism in core system
design is becoming the norm, rather than a special case for 'large' systems.

And that's just talking about desktop systems; now there are smart phones, netbooks, tablets, and
probably will shortly be other device types that this author can't imagine (else I'd be working on
them...).

In short, X11 was designed for a different era of computing.

This is not to say that there's an X12 project. There isn't. But if one day there is...

…You can read the full story at http://www.x.org/wiki/Development/X12/
Wayland
Wayland architecture
1.
2.
3.
4.
The kernel gets an event and sends it to the
compositor. This is similar to the X case.
The compositor looks through its scenegraph
to determine which window should receive
the event.
As in the X case, when the client receives
the event, it updates the UI in response.
The compositor collects damage requests
from its clients and then recomposites the
screen.
XWayland was written to enable running X11
applications through an X server, optionally rootless,
running as a Wayland client. This is similar to the
way X applications run in OS X’s native graphics
environment
Wayland
Wayland uses direct rendering over EGL
Wayland compositors
Display servers that implement the Wayland display
server protocol are also called Wayland compositors
because they additionally perform the task of a
compositing window manager.
 Weston – the reference implementation of a
Wayland compositor; Weston implements clientside decoration
 Lipstick – mobile user experience (UX) framework
which implements Wayland compositor. It is used
in Sailfish OS and Nemo Mobile.
 Enlightenment 0.19 (E19) is expected to have full
Wayland support.
 KWin had incomplete Wayland support in April
2013.
 Mutter maintains a separate branch for the
integration of Wayland for GNOME 3.9 (in
September 2013).
 Clayland is a simple example Wayland compositor
using Clutter.
Wayland: Planned adoption








Enlightenment: The Enlightenment project declared full support for Wayland with their Enlightenment
Foundation Libraries and window manager.
Fedora: Fedora ships Wayland since release 17. Fedora developer Matthias Clasen released a tentative
roadmap in March 2013, targeting to use Wayland as default by Fedora 21. Fedora 20 ships with a
technology preview of a Wayland-enabled Gnome 3.10 session.
GNOME: In March 2013 GNOME developers announced plans for a complete Wayland port within a year.
GNOME 3.10 includes initial support that "will enable the project to fully adopt the next generation display
and input technology in the future". The current roadmap targets GNOME 3.12 as the first version to be
fully ported to Wayland.
KWin, the KDE's window manager, added support for OpenGL ES output in version 4.7. In January 2013
KWin’s main developer Martin Grässlin started working for Blue Systems with one of the goals being a
complete Wayland port. Experimental Wayland support is now working in current KWin 4.11.
KDE’s Calligra Suite already has an unofficial but working port to Wayland.
Mate desktop: Wayland support is on Mate’s roadmap. The targeted Mate version is 1.10.
Raspberry Pi: The Raspberry Pi Foundation are working in collaboration with Collabora to improve
performance and memory consumption, but do not expect to be able to replace X11 as the default display
server until later in 2013.
Intelligent Input Bus is working on Wayland support, it could be ready for Fedora 22
Mir
Mir is a computer display server for Linux in development by
Canonical Ltd. It is planned to replace the currently used X Window
System for Ubuntu.
Mir, like Wayland, is built on EGL and uses some of the infrastructure
originally developed for Wayland such as Mesa’s EGL implementation
and Jolla’s libhybris. The compatibility layer for X, XMir, is based on
XWayland.
Mir: Adoption
As of May 2014 the only announced desktop environment with native support for Mir is Canonical's Unity 8. No other Linux
distribution has announced plans to adopt Mir as default display manager.
On 23 July 2013, Compiz developer Sam Spilsbury announced a proof-of-concept port of XBMC to Mir, based on the previous
proof-of-concept port of XBMC to Wayland. On the same day Canonical developer Oliver Ries confirmed that "this is the first
native Mir client out in the wild".
Among Ubuntu derivatives using a non-Unity environment, Xubuntu developers announced in early August 2013 that they would
evaluate running Xfce via XMir, but three weeks later decided to refrain from adopting it.
Ubuntu:

In June 2013 Canonical's publicly announced milestones for Mir development were to ship Unity 7 with XMir by default and
a pure X11 fallback mode with Ubuntu 13.10, remove the X11 fallback with Ubuntu 14.04 LTS, and Unity 8 running natively
on Mir by Ubuntu 14.10.

Later, on 1 October 2013, Canonical announced a postponement of their Mir plans for desktop use and not use XMir as
default in Ubuntu 13.10. Ubuntu Touch, however is targeted to ship with Mir and a smartphone version of Unity 8.

In March 2014 Mark Shuttleworth confirmed that Mir development had been delayed and that it was now forecast to be
default for desktop use in Ubuntu 16.04 LTS, expected to be released in April 2016.
ROOT GUI
 X11 Will (sooner or later) disappear, and a compatibility layer will
probably stay for a while, but be prepared for the change
 Adding another incarnation of TVirtualX to support yet another
backend could be a solution, but using which
architecture/technology?
 A complete rewrite of the GUI, without having a “X11 like”
approach would be nice, but the cross-platform layer is still an
issue: implementing the platform-dependent layers would be a
killer
 Possible solution: Use existing GUI toolkit
GUI Toolkits
 Many cross-platform C++ GUI toolkits already exist:
•
•
•
•
•
•
•
•
Qt
GTK+
FLTK
Fox (based on Xclass 95, like ROOT)
TnFOX
wxWidgets (WxWindows license)
CEGUI (MIT license)
Juce (GPL, commercial)