GUI

From Things and Stuff Wiki
Jump to navigation Jump to search


General



framebuffer

  • https://en.wikipedia.org/wiki/Framebuffer - frame buffer, or sometimes framestore, is a portion of RAM containing a bitmap that drives a video display. It is a memory buffer containing a complete frame of data. Modern video cards contain framebuffer circuitry in their cores. This circuitry converts an in-memory bitmap into a video signal that can be displayed on a computer monitor.

In computing, a screen buffer is a part of computer memory used by a computer application for the representation of the content to be shown on the computer display. The screen buffer may also be called the video buffer, the regeneration buffer, or regen buffer for short. Screen buffers should be distinguished from video memory. To this end, the term off-screen buffer is also used.

The information in the buffer typically consists of color values for every pixel to be shown on the display. Color values are commonly stored in 1-bit binary (monochrome), 4-bit palettized, 8-bit palettized, 16-bit high color and 24-bit true color formats. An additional alpha channel is sometimes used to retain information about pixel transparency. The total amount of memory required for the framebuffer depends on the resolution of the output signal, and on the color depth or palette size.


  • https://en.wikipedia.org/wiki/Linux_framebuffer - fbdev is a graphic hardware-independent abstraction layer to show graphics on a computer monitor, typically on the console. The word framebuffer means a part of video memory containing a current video frame, and the Linux framebuffer means “access method to the framebuffer under the Linux kernel”, without relying on system-specific libraries such as SVGALib or another user space software.

Startup

  • fbsplash (formerly gensplash) is a userspace implementation of a splash screen for Linux systems. It provides a graphical environment during system boot using the Linux framebuffer layer.
Q: "I get a tty1 login before KDM pops up."
A: "You could disable tty1. Comment out this line in /etc/inittab: 
  c1:2345:respawn:/sbin/agetty -8 38400 tty1 linux"

DirectFB

  • directfb.net - a thin library that provides hardware graphics acceleration, input device handling and abstraction, integrated windowing system with support for translucent windows and multiple display layers, not only on top of the Linux Framebuffer Device. It is a complete hardware abstraction layer with software fallbacks for every graphics operation that is not supported by the underlying hardware. DirectFB adds graphical power to embedded systems and sets a new standard for graphics under Linux. [1]
  • fbv - a very simple graphic file viewer for the framebuffer console, capable of displaying GIF, JPEG, PNG and BMP files using libungif, libjpeg, and libpng. The image can be shown either in fit-to-screen or panning mode in 8, 15/16, and 32bpp.



SVGAlib

  • SVGAlib Tutorials - provides an easy way to create graphical applications and eliminates the rigmarole of the X Window System. If you have even the most rudimentary grasp of programming in C, then you can use SVGAlib.

GTK

Xvfb

  • Xvfb - or X virtual framebuffer is a display server implementing the X11 display server protocol. In contrast to other display servers Xvfb performs all graphical operations in memory without showing any screen output. From the point of view of the client, it acts exactly like any other X display server, serving requests and sending events and errors as appropriate. However, no output is shown. This virtual server does not require the computer it is running on to even have a screen or any input device. Only a network layer is necessary. Unlike a real display server, Xvfb does not support modern X11 extensions like compositing, Randr or GLX. Xdummy is a newer alternative which supports these extensions as well as providing the same functionality as Xvfb. Xvfb is primarily used for testing.

Display server

X Window System


Xwindows drives the underlying graphical interface of most if not all Unix/Linux computers providing a GUI. It was developed in 1984 at MIT. After around 35 years of development, tweaking and adding of new hardware and ideas, it is generally acknowledged to be a bit of a beast. It should be remembered that the common configuration at time of development was a single mini running X providing individual views to Xterminals in a timesharing system. Nowadays the norm is X providing a single screen on a desktop or laptop.

All of this means that there are many ways of achieving the same thing and many slightly different things that can meet the same purpose. In modern X versions sometimes you can get away with limited or no configuration. In the last few years the boast is that X is self configuring. Certainly the best practice rule of thumb is less configuration is better - that is only configure what is wrong.

Xorg

  • X.Org project provides an open source implementation of the X Window System. The development work is being done in conjunction with the freedesktop.org community. The X.Org Foundation is the educational non-profit corporation whose Board serves this effort, and whose Members lead this work.


X11: /usr/lib/X11 /etc/X11 /usr/include/X11 /usr/share/X11





  • A Testament to X11 Backwards Compatibility - I recently scored a Hewlett Packard 1670A Deep Memory Logic Analyzer and I finally had a chance to fire it up. This unit dates back to 1992 and is packed with all sorts of interesting options for connecting peripherals to it. One particular feature that caught my eye was the option to connect to an X Server.

History

Legacy X servers

  • https://en.wikipedia.org/wiki/XFree86 - was an implementation of the X Window System. For most of the 1990s and early 2000s, the project was the source of most innovation in X and was the de facto steward of X development. Until early 2004, it was almost universal on Linux and the BSDs. In February 2004, with version 4.4.0, The XFree86 Project adopted a license change that the Free Software Foundation considered GPL incompatible. Most open source operating systems using XFree86 found this unacceptable and moved to a fork from before the license change. The first fork was the abortive Xouvert, but X.Org Server soon became dominant. Most XFree86 developers also moved to X.Org.

Startup

/etc/X11/xinit/xinitrc
if [ -d /etc/X11/xinit/xinitrc.d ]; then
       for f in /etc/X11/xinit/xinitrc.d/*; do
               [ -x "$f" ] && . "$f"
       done
       unset f
fi


Config

You can create a basic xorg.conf using the X executable itself. As root run:

Xorg :1 -configure

This will create the file /root/xorg.conf.new, which you can then copy to /etc/X11/xorg.conf:

cp /root/xorg.conf.new /etc/X11/xorg.conf


xrdb
xset



In case monitors don't report EDID information, modeline settings might required.

cvt 1280 1024 75


randr

  • http://en.wikipedia.org/wiki/RandR - a communications protocol written as an extension to the X11[2] protocol. XRandR provides the ability to resize, rotate and reflect the root window of a screen. RandR is also responsible for setting the screen refresh rate.


xrandr -q
  show possible and current screen resolutions
xdpyinfo | grep 'dimensions:'
  show just current screen resolution in px and mm


xrandrr='xrandr --output DVI-I-1 --mode 1280x1024 --pos 0x0 --panning 0x0+0+0 --output DVI-I-0 --mode 1280x1024 --pos 1280x0'

xrandrc='xrandr --output DVI-I-1 --same-as DVI-I-0'

xrandr --output DVI-I-1 --off

xrandr --output TV-0 --mode 1024x768 --pos 0x0 --panning 0x0+0+0 --output DVI-I-0 --mode 1280x1024 --pos 1024x0


  • ARandR is designed to provide a simple visual front end for XRandR. Relative monitor positions are shown graphically and can be changed in a drag-and-drop way.
  • autorandr - Auto-detect the connect display hardware and load the appropiate X11 setup using xrandr or disper


  • randrctl - Minimalistic JSON profile based screen manager for X. It allows to store current screen setup in a declarative configuration file (a profile) and apply stored settigns later with a simple command.

Multihead

faulty EDID;

  • DMX (Distributed Multihead X Project) - Typical X servers provide multi-head support for multiple displays attached to the same machine. When Xinerama is in use, these multiple displays are presented to the user as a single unified screen. Xdmx is proxy X server that provides multi-head support for multiple displays attached to different machines (each of which is running a typical X server). When Xinerama is used with Xdmx, the multiple displays on multiple machines are presented to the user as a single unified screen. A simple application for Xdmx would be to provide multi-head support using two desktop machines, each of which has a single display device attached to it.

Other

  • Disper is an on-the-fly display switch utility. It is intended to be used just before giving a presentation with a laptop, when all one wants is that the beamer, which has just been connected, is able to show whatever you prepared. Disper gives you the option to either clone all detected displays, or extend the desktop to them. Resolutions are automatically detected. For cloning, the highest common resolution supported by all displays is chosen; for extending every display device gets its highest supported resolution. For special setups requiring more detailed control, one can still use the standard display configuration utilites.

Switching

Remote

X's network transparency was not designed as 'it will run xterm well'; originally it was to be something that should let you run almost everything remotely, providing a full environment. ... You cannot operate with X over the network in the same way that you do locally. Trying to do so is painful and involves many things that either don't work at all or perform so badly that you don't want to use them.

X Forwarding

Requires xorg-xauth and xorg-xhost packages on the remote machine.

Remote /etc/ssh/sshd_config:

AllowTcpForwarding yes
X11UseLocalhost yes

X11DisplayOffset 10

X11Forwarding yes

Remote /etc/ssh/ssh_config:

Compression yes

Local /etc/ssh/ssh_config (optional, flag is -X)

ForwardX11 yes
ssh -XC user@host
  # X forwarding, compression

xclock
  # remote xclock should appear locally

xhost +192.168.1.64
  # add address to x access control list
mcookie
  # generate magic cookie on remote, i.e., bc85bb773ae8897d9569ddbe69684411
xauth add node10/unix:3 . bc85bb773ae8897d9569ddbe69684411
  # add remote to local xauth list

xauth list
  # list X magic cookies
  • https://wiki.archlinux.org/index.php/Xhost - used to add and delete host names or user names to the list allowed to make connections to the X server. In the case of hosts, this provides a rudimentary form of privacy control and security. It is only sufficient for a workstation (single user) environment, although it does limit the worst abuses.

Xnest

  • Xnest is both an X client and an X server. Xnest is a client of the real server which manages windows and graphics requests on its behalf. Xnest is a server to its own clients. Xnest manages windows and graphics requests on their behalf. To these clients, Xnest appears to be a conventional server.
    • http://en.wikipedia.org/wiki/Xnest - a display server implementing the X11 display server protocol that shows its output in a window. In other words, Xnest opens a window that works like another screen in which the user can open windows, etc.

Xephyr

  • Xephyr is a kdrive based X Server which targets a window on a host X Server as its framebuffer. Unlike Xnest it supports modern X extensions (even if host server doesn't) such as Composite, Damage, randr etc (no GLX support now). It uses SHM Images and shadow framebuffer updates to provide good performance. It also has a visual debugging mode for observing screen updates.
Xephyr -br -ac -noreset -screen 800x600 :1 &

DISPLAY=:1 xterm
startx -- /usr/bin/Xephyr :1

Xpra

  • Xpra - X Persistent Remote Applications, is 'screen for X', and more: it allows you to run X programs, usually on a remote host and direct their display to your local machine. It also allows you to display existing desktop sessions remotely. Xpra is "rootless" or "seamless", and sessions can be accessed over SSH, or password protected and encrypted over plain TCP sockets. Xpra adapts to bandwidth constraints and is fully open-source. [6]

The main problem with ssh -X is all your apps close when your connection drops.

xpra shadow ssh:milk@silver.local:0 --ssh="/usr/bin/ssh p=231"
  # shadow the display on a remote machine


  • Xdummy was originally developed by Karl Runge as a ​script to allow a standard X11 server to be used by non-root users with the dummy video driver

x2x

x2vnc

  • x2vnc - A dual-screen hack. will let you use two screens on two different computers as if they were connected to the same computer. Even if one of the computers runs Windows 95/98/NT and the other one runs X-windows. The program will open a small (one pixel wide) window on the edge of your screen. Moving the pointer into this window will trigger the program to take over your mouse and send mouse movements and keystrokes though the RFB protocol to a VNC server running on another machine. When the pointer is moved back towards the opposite edge on the other screen, the mouse is then released again. The operation itself is almost identical to x2x, but most of the code was actually borrowed from the program vncviewer.

x11vnc

  • x11vnc allows one to view remotely and interact with real X displays (i.e. a display corresponding to a physical monitor, keyboard, and mouse) with any VNC viewer. In this way it plays the role for Unix/X11 that WinVNC plays for Windows.

xrdp

  • xrdp - An open source remote desktop protocol(rdp) server. Based on the work of FreeRDP and rdesktop, xrdp uses the remote desktop protocol to present a GUI to the user. The goal of this project is to provide a fully functional Linux terminal server, capable of accepting connections from rdesktop, freerdp, and Microsoft's own terminal server / remote desktop clients. Unlike Windows NT/2000/2003/2008/2012 server, xrdp will not display a Windows desktop but an X window desktop to the user. Xrdp uses Xvnc or X11rdp to manage the X session.

xmove

  • xmove - a computer program that allows the movement of X Window System applications between different displays and the persistence of X applications across X server restarts. It solves a problem in the design of X, where an X client (an X application) is tied to the X server (X display) it was started on for its lifetime. Also, if the X server is shut down, the client application is forced to stop running. xmove lets the client disconnect from its current X server, and connect to a new one, at any time. The transition is completely transparent to the client. xmove works by acting as a proxy between the client and server. It is a "pseudoserver" which stores enough server state so that clients can connect to a new server without being disrupted.

Guievict

  • guievict is a computer program which enables the GUI of any application for XFree86 implementation of X Window to be transparently migrated to or replicated on another display. Unlike some program providing similar functionalities, it requires neither prearranging steps such as re-linking the application program binary nor re-directing the application process's window system communication through a proxy like xmove does.

DXPC

Utils

  • xprop - property displayer for X

xprop

xprop -root
  # list root (wm) window properties

xprop -root -f _NET_DESKTOP_GEOMETRY 32cc -set _NET_DESKTOP_GEOMETRY "$GEOM_X,$GEOM_Y"
  # set _NET_DESKTOP_GEOMETRY. only applies if wm supported.

xev

  • xev - print contents of X events
    • 'keysym' gives the name to bind to

xwit

  • xwit is an X window interface tool. By default when used with no arguments in an xterm it de-iconifies and raises the window. You can specify a different function to do, such as iconifying the window, and apply it to several windows whose name begins with one of the given strings, or a particular window id given, or the window id found in the environment variable WINDOWID (which is set by xterm for the program it runs), or the window under the mouse cursor.

xdo

  • xdotool - lets you simulate keyboard input and mouse activity, move and resize windows, etc. It does this using X11's XTEST extension and other Xlib functions. Additionally, you can search for windows and move, resize, hide, and modify window properties like the title. If your window manager supports it, you can use xdotool to switch desktops, move windows between desktops, and change the number of desktops.

wmctrl

  • wmctrl is a UNIX/Linux command line tool to interact with an EWMH/NetWM compatible X Window Manager.

wmutils

  • chwb - change window's border
  • chwso - change window's stacking order
  • ignw - ignore/unignore window
  • killw - kill windows
  • lsw - list windows
  • mapw - map/unmap windows
  • pfw - print focused window
  • wattr - show window's attributes
  • wmp - move the mouse pointer
  • wmv - move a window
  • wrs - resize a window
  • wtf - focus a window
  • wtp - teleport a window


X11fs

xmag

  • xmag - allows you to magnify portions of an X screen. If no explicit region is specified, a square with the pointer in the upper left corner is displayed indicating the area to be enlarged. The area can be dragged out to the desired size by pressing Button 2. Once a region has been selected, a window is popped up showing a blown up version of the region in which each pixel in the source image is represented by a small square of the same color. Pressing Button1 in the enlargement window shows the position and RGB value of the pixel under the pointer until the button is released. Typing Q or ^C in the enlargement window exits the program.

xinput

  • xinput - utility to configure and test X input devices

XMacro

  • XMacro - package contains two simple, C++ programs (xmacrorec and xmacroplay) for recording and replaying keyboard and mouse events on an X server. This functionality is achieved through the XTest extension.

devilspie

KPie

  • KPie is a simple window manipulation tool, modeled after devil's pie, with a Lua-based configuration file.

telak

  • telak is a program which displays pictures in root window. It can display content of local file, or download image via http. Telak can be configured to refetch picture every n seconds, so it can be used to display image from webcam.

Xearth

  • Xearth sets the X root window to an image of the Earth, as seen from your favorite vantage point in space, correctly shaded for the current position of the Sun. By default, xearth updates the displayed image every five minutes. The time between updates can be changed using either X resource or a command-line option. Xearth can also be configured to either create and render into its own top-level X window or render directly into PPM or GIF files; see the man page for details.

Xplanet

  • Xplanet was inspired by Xearth, which renders an image of the earth into the X root window. All of the major planets and most satellites can be drawn, similar to the Solar System Simulator. A number of different map projections are also supported, including azimuthal, Lambert, Mercator, Mollweide, orthographic, and rectangular.


Xeyes

Xsnow

xcwd

xterm -e "cd `xcwd` && /bin/zsh"

Other


  • https://github.com/andrewchambers/godothecorrectthing - A script to do actions based on the current window and selected text. With this you can: Select any compiler error text in any terminal and open the correct file and line in your text editor. Click on the output of ls in any terminal and open the corresponding file with the correct program. Open any url from any text on your OS and open it in your browser.


  • https://github.com/lleonini/lightsOn - Bash script that prevents the screensaver and display power management (DPMS) to be activated when you are watching Flash(and HTML5) Videos fullscreen on Firefox, Chromium, Google Chrome. Can detect mplayer, minitube, and VLC when they are fullscreen too. Also, screensaver can be prevented when certain specified programs are running. This script can be used to control X11 Screen Saver Extension and DPMS settings, read the source. Optionally can delay the screensaver when specific outputs are connected.


  • Xantfarm simulates an ant hill and displays it in the root window.


  • blast Blast blows holes through windows
  • xhangglider - fly hanggliders and paragliders on your X root window.


  • xdesktopwaves - a cellular automata setting the background of your X Windows desktop under water. Windows and mouse are like ships on the sea. Each movement of these ends up in moving water waves. You can even have rain and/or storm stirring up the water.

Programming


Pointer

Scripts GUI

  • xmessage − display a message or query in a window (X-based /bin/echo)
  • Gxmessage is an xmessage clone for GTK based desktops. Gxmessage pops up a dialog window, displays a given message or question, then waits for the user's response. That response is returned as the program's exit code. Because gxmessage is a drop-in alternative to xmessage, gxmessage accepts any option xmessage would, and returns the same exit codes.
  • Dialog is a program that will let you to present a variety of questions or display messages using dialog boxes from a shell script. These types of dialog boxes are implemented (though not all are necessarily compiled into dialog): calendar, checklist, dselect, editbox, form, fselect, gauge, infobox, inputbox, inputmenu, menu, mixedform, mixedgauge, msgbox (message), passwordbox, passwordform, pause, progressbox, radiolist, tailbox, tailboxbg, textbox, timebox, and yesno (yes/no).
  • whiptail - display dialog boxes from shell scripts


Backgrounds



Fonts




Some fonts like terminus-font are installed in /usr/share/fonts/local, which is not added to the font path by default. By adding the following lines to ~/.xinitrc, the fonts can be used in X11:

xset +fp /usr/share/fonts/local
xset fp rehash
/usr/share/fonts/misc/fonts.alias
  # shortnames for fonts



Keyboard input


xmodmap

xmodmap -pke | column -t
  # display keymaps in columns

Each keysym column in the table corresponds to a particular combination of modifier keys:

  • Key
  • Shift+Key
  • mode_switch+Key
  • mode_switch+Shift+Key
  • AltGr+Key
  • AltGr+Shift+Key
xmodmap -e "pointer = 3 2 1"
  # set mouse buttons for left hand

xmodmap -e "pointer = 1 2 3"
  # set mouse buttons for right hand

xkeycaps

  • xkeycaps - a graphical front-end to xmodmap. It opens a window that looks like a keyboard; moving the mouse over a key shows what KeySyms and Modifier bits that key generates. Clicking on a key simulates KeyPress/KeyRelease events on the window of your choice. It is possible to change the KeySyms and Modifiers generated by a key through a mouse-based interface. This program can also write an input file for xmodmap to recreate your changes in future sessions.


xbindkeys

~/.xbindkeysrc

sxhkd


~/.config/sxhkd/sxhkdrc

Other

  • https://github.com/wertarbyte/triggerhappy - a hotkey daemon developed with small and embedded systems in mind, e.g. linux based routers. It attaches to the input device files and interprets the event data received and executes scripts configured in its configuration.
  • https://github.com/alols/xcape - allows you to use a modifier key as another key when pressed and released on its own. Note that it is slightly slower than pressing the original key, because the pressed event does not occur until the key is released. The default behaviour is to generate the Escape key when Left Control is pressed and released on its own. (If you don't understand why anybody would want this, I'm guessing that Vim is not your favourite text editor ;)
  • http://xautomation.sourceforge.net - XAUT (the C library) and the corresponding Python module is a way to programatically simulate keyboard and mouse use, as well as manipulate windows. The inspiration for this came from AutoIt as well as AutoHotkey.







  • http://imwheel.sourceforge.net/imwheel.1.html - a universal mouse wheel and mouse stick translator for the X Windows System. Using either a special version of gpm and it's /dev/gpmwheel FIFO, or the support for a ZAxis on the mouse built into some servers, such as XFree86. Utilizing the input from gpm or X Windows, imwheel translates mouse wheel and mouse stick actions into keyboard events using the XTest extension to X. Use xdpyinfo for information on the supported extensions in your X server.
  • LinEAK - a utility designed to enable the use and configuration of those special keys on Internet, Easy Access and Multimedia keyboards in Linux. It consists of three programs: lineakd: this is the daemon that listens for incoming key and mouse events. lineakconfig: this is the GTK+ GUI, which provides easier configuration. Klineakconfig: this is the KDE GUI which allows you to define keyboards, and configuration mappings for easier configuration. If your keyboard is not directly supported by lineakd, klineakconfig provides an easy to use graphic interface to both getting your keyboard working, and submitting your keyboard for inclusion into lineakd.




Virtual keyboard

xvkbd

  • xvkbd - a virtual (graphical) keyboard program for X Window System which provides a facility to enter characters onto other clients (software) by clicking on a keyboard displayed on the screen. This may be used for systems without a hardware keyboard such as kiosk terminals or handheld devices. This program also has a facility to send characters specified as the command line option to another client.

GOK

  • GOK - Gnome Onscreen Keyboard

Florence

  • Florence - an open-source on-screen virtual keyboard developed in C and GTK+ for X11 desktop system. As an alternative to a hardware keyboard, Florence allows users to enter characters using a pointing device such as a mouse, a trackball or a touchscreen. It offers four different input method: mouse-based input, touch-screen based input, timer-based auto click, and rambling-based input. Florence supports international keyboard layouts with non-English characters, auto-hide mode, and custom keyboard layout. The default keyboard can be extended to include function keypad, number keypad, arrow keypad, and action keypad. Florence can be integrated with GNOME Display Manager (GDM) to show a virtual keyboard during GNOME desktop login.

Onboard

Keyboard layout

Drag and drop

  • https://github.com/mwh/dragon - simple drag-and-drop source/sink for X. Many programs, particularly web applications, expect files to be draggedinto them now. If you don't habitually use a file manager that is a problem. dragon is a lightweight drag-and-drop source for X where you can run "dragon file.tar.gz" to get a window with just that file in it, ready to be dragged where you need it.


Cursor

xsetroot -cursor_name left_ptr


Backlight

Intel chipset:

Section "Device"
   Identifier  "Card0"
   Driver      "intel"
   Option      "Backlight"  "intel_backlight"
EndSection

xdimmer

  • xdimmer is a lightweight X11 utility to dim the screen backlight when idle, then brighten it back up when mouse or keyboard activity is detected. This power-saving behavior is common on other operating systems and in bloated X11 frameworks like GNOME.

light

  • Light - a program to control backlight controllers under GNU/Linux, it is the successor of lightscript, which was a bash script with the same purpose, and tries to maintain the same functionality.

DPMS

Add the following to a file in /etc/X11/xorg.conf.d/ in the Monitor section:

Option "DPMS" "true"

Add the following to the ServerLayout section, change the times (in minutes) as necessary:

Option "StandbyTime" "10"
Option "SuspendTime" "20"
Option "OffTime" "30"

Or to change on the fly:

xset s off
  # Disable screen saver blanking
xset s 3600 3600
  # Change blank time to 1 hour

xset -dpms
  # Turn off DPMS
xset s off -dpms
  # Disable DPMS and prevent screen from blanking

xset dpms force off
  # Turn off screen immediately
xset dpms force standby
  # Standby screen
xset dpms force suspend
  # Suspend screen

freedesktop.org

Autostart

  • dapper - a simple lightweight desktop application auto-starter. It will read .desktop files in the autostart directories, all according to the FreeDesktop autostart specifications. You can define which desktop to start applications for (e.g. GNOME, XFCE, etc) in configuration file (~/.config/dapper.conf) or from command line. Note that autostarting desktop application is probably already taken care of if you do use a desktop environment/session manager.


ICCCM

  • http://en.wikipedia.org/wiki/Inter-Client_Communication_Conventions_Manual - ICCCM or I39L short for "I", 39 letters and "L")[1] is a standard for interoperability between X Window System clients of the same X server. It is primarily used for communication between normal clients and the window manager. X deliberately specifies "mechanism, not policy". As such, an additional specification beyond the X protocol itself was needed for client interoperation. The ICCCM specifies cut and paste buffers, window manager interaction, session management, how to manipulate shared resources and how to manage device colours. These low-level functions are generally implemented within widget toolkits or desktop environments, meaning that application programmers rarely work directly with the ICCCM itself but instead use the higher-level toolkit functions that implement it.

EWMH

  • http://en.wikipedia.org/wiki/Extended_Window_Manager_Hints - aka NetWM or Net WM, is an X Window System standard for window managers. It defines various interactions between window managers, utilities, and applications, all part of an entire desktop environment. It builds on the functionality of the Inter-Client Communication Conventions Manual (ICCCM).



  • ewmhstatus - Outputs the current EWMH desktop name and window title

"The main caveats are that in Xinerama/XRandR mode, you'll have only one root window. And the root window is where you must store the NET_WM X properties… So you cannot handle screens in a independant way like awesome does. That's really a shame. ... So far, I think EWMH is nice but is really too narrow-minded for software and people who want to think window management in a different way."

3D

Video

Scaling

Automation

XAUT

  • XAUT - C library and the corresponding Python module, a way to programatically simulate keyboard and mouse use, as well as manipulate windows. The inspiration for this came from AutoIt as well as AutoHotkey.

xlax

  • xlax - accepts keyboard input from the user and sends it to multiple X11 windows (usually xterms or other terminal windows). It's an ideal tool for system adminstrators who have to do the same thing on multiple machines, or in multiple directories. It allows the virtual connections to windows to be turned on and off, so that only a subset of current windows are in use (this is shown in the diagram above, where the third and fifth windows in the list are not selected). The user can also assign a different text string to each window which will be sent by clicking on the "Send String" button. In a typical usage, a user might need to check a few things and run a number of commands on five different machines. After setting up all the windows to work with xlax (see below), and with send strings set to hostnames, the user will type "ssh " and then click "Send String", and then type return, and the user will simultaneously log into those five different machines. They can then type the commands once and see them run on all machines at the same time.

Display Managers

  • https://wiki.archlinux.org/index.php/Display_Manager - X Display Manager is used to start a session from a local system or from another computer. The request and the start of the session is handled by the XDMCP, which stands for "X Display Manager Control Protocol" and is a network protocol. It provides a way of running the X-Terminal to run on your PC (or MAC) and it uses the X Server to provide a client/server interface between display hardware (the mouse, keyboard, and video displays) and the desktop environment while also providing both the windowing infrastructure and a standardized application interface (quoted from XFree86 Project home page)



X Window System is the display and networking protocol developed by MIT. The X is built with network in mind with the capability to run a (graphical) session on a remote computer. In it, an X Display Manager is used to start a session from a local system or from another computer. The request and the start of the session is handled by the XDMCP, which stands for "X Display Manager Control Protocol" and is a network protocol. It provides a way of running the X-Terminal to run on your PC (or MAC) and it uses the X Server to provide a client/server interface between display hardware (the mouse, keyboard, and video displays) and the desktop environment while also providing both the windowing infrastructure and a standardized application interface (quoted from XFree86 Project home page). The X-Terminal can be displayed with an individual window or multiple windows, based on your X window system's software capabilities and setup.

XDM




xlogin

WDM

SLiM

Security issues.

username:

exit - Return to the command line
halt - Shutdown the system
reboot - Reboot the system
console - Launch the terminal
cd /usr/share/slim/themes/
slim -p [name of theme]
  # preview theme (needs to be killed from a non-X tty!)

Enterance

SDDM

LightDM

GDM

cdm

tdm

nodm

  • https://github.com/spanezz/nodm - a minimal display manager that simply logs in as a given user and starts an X session, without asking for username or password.On a normal computer, using nodm is a big security issue because it would give anyone access to the computer. However, there are cases where automatic login is needed: for example in an embedded system such as a mobile phone, or in a kiosk setup, or in a control panel for industrial machinery. For those cases, nodm is simple to setup, lightweight, and it should do exactly the right thing.

Session managers

ugh


  • smproxy - allows X applications that do not support X11R6 session management to participate in an X11R6 session.
  • dtsession - the CDE Session Manager, provides X11R6 XSMP and (by proxy) ICCCM 1.1 compliant session management functionality during a user session, which is the time from login to logout. It launches a window manager and allows for saving a session, restoring a session, locking a session, launching screen savers and allocating colors for desktop compatible clients.




  • selectwm - a small application (using GTK+) which lets you select your window manager. It looks for a file named .selectwmrc in the user's directory which contains a list of window managers. When you start X it should show a list which lets you choose your window manager (by double clicking on it with the mouse or with the arrow keys and the return or space key)

Compositing

Older

Compton

  • Compton - "I was frustrated by the low amount of standalone lightweight compositors. Compton was forked from Dana Jansens' fork of xcompmgr and refactored. I fixed whatever bug I found, and added features I wanted. Things seem stable, but don't quote me on it. I will most likely be actively working on this until I get the features I want. This is also a learning experience for me. That is, I'm partially doing this out of a desire to learn Xlib."

Unagi

Window Managers

xwm

xnwm

mwm

198?

uwm

1985

developed by the Digital Equipment Corporation for their Ultrix operating system. It was released in 1985. Shortly thereafter, it became included as part of the base X Window System distribution, beginning with X10R3. Initially, it was distributed alongside two other window managers (xwm and xnwm).

In 1986, the X Window System switched to version 11 of the protocol. Only uwm was ported, so it became the only window manager for X Window System until X11R4 release, where it was replaced by twm. uwm has never been updated since.

twm

1987

The name originally stood for Tom's Window Manager, but the software was renamed Tab Window Manager by the X Consortium when they adopted it in 1989 (X11R4).

twm is a re-parenting window manager that provides title bars, shaped windows and icon management. It is highly configurable and extensible. twm was a breakthrough achievement in its time, but it has been largely superseded by other window managers which, unlike twm, use a widget toolkit rather than writing directly against Xlib.

Various other window managers—such as vtwm, tvtwm, CTWM, and FVWM—were built on twm's source code.

awm

1988

descended from uwm.

olvm / olvwm

1989 / 1996?

OPEN LOOK Window Manager was the default stacking window manager for OpenWindows, the original desktop environment included with SunOS and Solaris. Its unique characteristic is its implementation of the OPEN LOOK look and feel.

Scott Oaks developed a variant of olwm, called olvwm (the OPEN LOOK Virtual Window Manager), which implements a virtual root window with dimensions greater than those of the video display.

swm

1989

Developed by Tom LaStrange at Solbourne Computer (computer workstations and servers based on the SPARC microprocessor architecture, largely compatible with Sun Microsystems' Sun-4 systems) in 1990. The most important innovation of swm was the introduction of the virtual desktop. It also introduced a primitive form of session management (restoring programs in use at the time of shutdown) to X.

Vtwm

1990

tvtwm

1991

Derived from twm to which it adds the virtual desktop feature from swm. All of these window managers were originally written by Tom LaStrange.

Unlike most more recent virtual window managers, tvtwm models the root window as a single large space, with the physical desktop being a viewport onto that virtual root window. The user can scroll the viewport around the virtual desktop either by pressing certain keys or by clicking into a scaled down representation of the virtual desktop, the so-called panner.

CTWM

1992

Claude Lecommandeur from the source code for twm, which, inspired by HP's vuewm, he extended to allow for virtual desktops ("workspaces" in CTWM's terminology.)

PieWM

1992

tvtwm fork, Has pie menus (circle around the mouse).

Motif Window Manager

1992

FVWM

1993

Derived from twm, has lots of forks: Afterstep, Xfce, Enlightenment, WindowMaker, Metisse, Bowman, AmiWM, FVWM-XPM (pre-Enlightenment), NWM, MVLWM, SCWM

9wm

1994

ADAM

1995

AmiWM

1996?

wm2 / wmx

1996 / 1998

Window Maker

1997


Blackbox

1997

Enlightenment

1997

  • Enlightenment is not just a window manager for Linux/X11 and others, but also a whole suite of libraries to help you create beautiful user interfaces with much less work than doing it the old fashioned way and fighting with traditional toolkits, not to mention a traditional window manager. It covers uses from small mobile devices like phones all the way to powerful multi-core desktops (which are the primary development environment).

IceWM

1997

MLVWM

1997

Xfwm

Xfwm - used in Xfce, intially based on fvwm2, itself derived from twm, redesigned to minimize memory consumption, provide a 3-D look to window frames, and provide a simple virtual desktop.

4Dwm

1998?

derived from mwm. uses the Motif widget toolkit, normally used on Silicon Graphics workstations running IRIX.

aewm

1998

AfterStep

1999

Scwm

1999

plwm

1999

PWM

2000

Tiling

Succeeded by Ion

Ion

2000

Tiling

Successor to PWM, development dead

Fork: Notion

Sawfish

2000

  • Sawfish is an extensible window manager using a Lisp-based scripting language. Its policy is very minimal compared to most window managers. Its aim is simply to manage windows in the most flexible and attractive manner possible. All high-level WM functions are implemented in Lisp for future extensibility or redefinition. what i wanted when using litestep

larswm

2000

ratpoison

2000

PLWM

2000

Fluxbox

2001

WindowLab

2001

Fork of aewm. Stacking.

evilwm

2001

Stacking, minimal/small.

Openbox

2002

Metacity

2002

miwm

2002

Hackedbox

2002

Oroborus

2002

NovaWM

2002

Stumpwm

2003

cwm

2004

Calm Window Manager, stacking. was based on evilwm, rewritten as a 9wn fork, then rewritten

wmii

2005

Tiling/stacking, plan9 like interface.

PekWM

2005

Stacking

JWM

2005

Stacking, Windows 98 like.

whimsy

2005

Python, stackable.

dwm

2006

Tiling, configuration in source header file.

spectrwm

2006

  • spectrwm is a small dynamic tiling window manager for X11. It tries to stay out of the way so that valuable screen real estate can be used for much more important stuff. It has sane defaults and does not require one to learn a language to do any configuration. It was written by hackers for hackers and it strives to be small, compact and fast. It was largely inspired by xmonad and dwm.

FLWM

2006?

Stacking, based on the FLTK toolkit

Matchbox

2007

xmonad

2007

  • xmonad is a dynamically tiling X11 window manager that is written and configured in Haskell. In a normal WM, you spend half your time aligning and searching for windows. xmonad makes work easier, by automating this.

Config

cabal --recompile
  after changing ~/.xmonad/xmonad.hs

Hotkeys

mod shift enter
  start terminal
mod shift c
  close current window

mod w
  reload xmonad

mod space
  rotate through window layouts
mod shift space
  reset to workspace default
mod tab
  tab through windows
super 2
  switch to workspace 2

Awesome

2007

Config

echo 'naughty.notify({ text = "hello from tty" })' | awesome-client

debug rc.lua changes;

Xephyr :1 -ac -br -noreset -screen 1152x720 &
DISPLAY=:1.0 awesome -c ~/.config/awesome/rc.lua.new

If xdg/awesome default config loads instead of .config/awesome, this is due to error in the rc.lua.

Usage

[mod]-Enter
  new terminal window
[mod]-c
  close window

[mod]-j
  rotate window selection clockwise
[mod]-k
  rotate window selection anticlockwise
[mod]-J
  move active window clockwise
[mod]-K
  move active window anticlockwise

[mod]-f
  fullscreen active window

[mod]-a
  create new tag
[mod]-s
  rename active tag
[mod]-shift-r
  reload awesome (to resource config)

Multihead

Wibox

Widgets

Colours

The color format in awesome is either a standard X color name (blue, darkblue, lightred, etc) or a hexadecimal formatted color (#rrggbb or #rrggbbaa). By using the hexadecimal format, you can also specify an alpha channel: that means that #00ff00 will draw pure green, but #00ff00aa will set the alpha channel to ‘aa’ and will blend the green with the color under it.

Text format

You can use Pango markup in a text string. This allows formating the text rendered inside widgets. Pango markup documentation can be found in the Pango documentation at http://library.gnome.org/devel/pango/stable/PangoMarkupFormat.html.

A Pango markup example: .

Shifty

Revelation

Expose-like client selection.

Freedesktop menu

MPD

Other

manager.


3.5

subtle

2007

  • subtle is a manual tiling window manager with a rather uncommon approach of tiling: Instead of relying on predefined layouts, subtle divides the screen into a grid with customizeable slots (called gravities). For better understanding, the default config uses a 3x3 grid and maps each gravity to one key of the numpad. With those keys, windows can be moved directly to the desired gravity - the same can be done with tagging rules in the config. Another unique concept is the strict tagging: Unlike other tiling window managers, subtle doesn't allow weak tagging and always maps windows to virtual desktops (called views) with matching tags, regardless of the current active view.

Echinus

2007

Tritium

2007?

  • https://github.com/stew/tritium - a tabbed/tiling window manager. tritium is a tiling/tabbed window manager for the X Window System inspired by the ion3 window manager. It was written completely from scratch in python and shares no actual code with ion3. tritium is implemented in python using the plwm ("pointless window manager") library

SithWM

2007

wmfs

2008

CLFSWM

2008

Lucca WM

2008?

i3

2009

Based on wmii, tiling/floating.






i3-msg exec application
  # start your application on the workspace where it was called






bindsym $mod+n exec i3-msg move to container workspace $(($(wmctrl -d | wc -l) + 1))
  # move to next numbered workspace whether existing or empty




  • https://github.com/joepestro/i3session - remembers what's running in your i3 workspaces by saving a session file (in ~/.i3/session). It is then able to restore the running processes (and their simple orientation) to one or more workspaces. Since i3session executes i3 commands sequentially (tree traversal), changing focus during restore will affect where clients open. By default, the i3-nagbar will appear during restore with a message to remind you of this.
  • https://github.com/pitkley/i3nator - Tmuxinator for the i3 window manager. It allows you to manage what are called "projects", which are used to easily restore saved i3 layouts (see Layout saving in i3) and extending i3's base functionality by allowing you to automatically start applications too.



jq:

.[].num

.[] | select(.visible and .focused).num+1)

if ([(.[][] | select(.visible == true) | select(.focused == true).num)+1] as $desk | [.[][].num] as $array | $array | contains($desk)) == true then "one" else "two" end

TinyWM

Notion

2010

Tiling, tabbed



Fork of Ion

Musca

2009

Bluetile

2010

  • Bluetile is a tiling window manager for Linux, designed to integrate with the GNOME desktop environment. It provides both a traditional, stacking layout mode as well as tiling layouts where windows are arranged to use the entire screen without overlapping. Bluetile tries to make the tiling paradigm easily accessible to users coming from traditional window managers by drawing on known conventions and providing both mouse and keyboard access for all features. based on Xmonad

mcwm

2010

catwm

2010

euclid-wm

2010

wind

2010

Wind is a window manager for the X Window System. It supports virtual desktops, optional Xft font rendering, and is pretty standards compliant. It provides overlapping window management with click-to-type focus. Unlike most window managers, Wind does not have the concept of minimized or hidden windows. Instead of hiding and unhiding windows, the virtual desktops abstraction makes it easy to group similar tasks and switch between these groups instantly using convenient key bindings. Standards compliancy is a prominent goal of the project, and Wind supports almost all mandatory parts of the ICCCM and the Extended Window Manager Hints specifications. Full compliancy is expected in the next major release.

marco

2011

Fork of metacity, used by MATE.

i5

2011

Tiling, fork of i3 with touchscreen features.

herbstluftwm

2011

  • herbstluftwm is a manual tiling window manager for X11 using Xlib and Glib. Its main features can be described with: the layout is based on splitting frames into subframes which can be split again or can be filled with windows (similar to i3/ musca). tags (or workspaces or virtual desktops or …) can be added/removed at runtime. Each tag contains an own layout. exactly one tag is viewed on each monitor. The tags are monitor independent (similar to xmonad). it is configured at runtime via ipc calls from herbstclient. So the configuration file is just a script which is run on startup. (similar to wmii/ musca)

monsterwm

2011

  • monsterwm is a minimal, lightweight, tiny but monstrous dynamic tiling window manager. It will try to stay as small as possible. Currently under 700 lines with the config file included. It provides a set of four different layout modes (vertical stack, bottom stack, grid and monocle/fullscreen) by default, and has floating mode support. Each virtual desktop has its own properties, unaffected by other desktops' settings. Finally monsterwm supports multiple monitors setups.

tilenol

2011

nwm

2011

  • nwm - A dynamic window manager for X11 written with Node.js

Mer

2011

dminiwm / snapwm

2011

Minimal and lightweight dynamic tiling window manager. Fork of catwm.

wingo

2011

Floating and tiling, per monitor desktops. Written in Go.

no-wm

2011

Foo-Wm

Aura

TTWM / Alopex

2012

  • https://github.com/TrilbyWhite/alopex
  • https://wiki.archlinux.org/index.php/Alopex
  • TTWM is a minimal tiling window manager combining concepts or elements from TinyWM, DWM, and i3wm. Inspiration has also been drawn from other great tilers like MonserWM. TinyTiler is currently under 650 lines of code. In contrast to other tilers, TinyTiler does not have modes nor does have window rules. TinyTiler has only two layouts: right stack and bottom stack. These choices were by design. TinyTiler instead provides two screen sections, the master and the stack. In TinyTiler only one stack window is visibile at a time, the others have tabs in the statusbar.

Qtile

2012

Goomwwm

2012

bspwm

2012

Very nice and atomic.

bspc set focused_border_color '#ff0000'
bspc set border_width '3px'
bspc set window_gap 0
bspc set focus_follows_pointer true

Deep Space Window Manager

2012

Piwm

2013

  • Piwm is a very small window manager written in Bash. Following are the 5 task it performs : 1) Ctrl + t : Opens xterm, 2) Ctrl + f : Makes current window full screen, 3) Alt + Mouseleft : Moves the window, 4) Alt + Mouseright : Rescales the window, 5) Ctrl + F1 : Refocus the window

Guile-WM

2013

FrankenWM

2014

dynamic tiling WM featuring the v-stack, b-stack, grid, fibonacci, dualstack, equal and monocle layouts out of the box. If you want to, you can add gaps between the windows as well. monsterwm-xcb fork, thus coming from monsterwm, thus coming from dminiwm, thus coming from catwm.

howm

2014

wtftw

2014

written in rust

adwm

2014

  • https://github.com/bbidulock/adwm - originally a fork of Echinus which in turn was a fork of dwm, and borrows concepts from velox, awesome and spectrwm. What it includes is a full rewrite with significant updates and additions resulting in full EWMH (NetwM), WMH (WinWM), MWMH (CDE/Motif), ICCCM 2.0 compliance and support.

eggwm

2014

swm

2014

exwm

2015

katriawm

2015

non-reparenting, tiling window manager with window decorations. It’s a learning project started in December 2015.

Lunchbox Window Manager

2015

Way Cooler

2016

other tiling

Desktop environment

as DEs are fairly tightly integrated, a full DE install is required for proper running and configuration of their component apps

OpenWindows

1989-2000, Sun Microsystems

Common Desktop Environment

1993-

GNOME



  • Glade is a RAD tool to enable quick & easy development of user interfaces for the GTK+ toolkit and the GNOME desktop environment. The user interfaces designed in Glade are saved as XML, and by using the GtkBuilder GTK+ object these can be loaded by applications dynamically as needed. By using GtkBuilder, Glade XML files can be used in numerous programming languages including C, C++, C#, Vala, Java, Perl, Python,and others.

shellshape

Consort

MATE

KDE




Cinnamon

Xfce

Lightweight, not entirely UNIXy, but hey..

LXDE / LXQt

ROX

  • ROX is a fast, user friendly desktop which makes extensive use of drag-and-drop. The interface revolves around the file manager, or filer, following the traditional Unix view that `everything is a file' rather than trying to hide the filesystem beneath start menus, wizards, or druids. The aim is to make a system that is well designed and clearly presented. The ROX style favours using several small programs together instead of creating all-in-one mega-applications.

Sugar

  • Sugar Labs - a learning platform that reinvents how computers are used for education. Collaboration, reflection, and discovery are integrated directly into the user interface. Sugar promotes "studio thinking" and "reflective practice". Through Sugar's clarity of design, children and teachers have the opportunity to use computers on their own terms. Students can reshape, reinvent, and reapply both software and content into powerful learning activities. Sugar's focus on sharing, criticism, and exploration is grounded in the culture of free software (FLOSS).

Trinity

  • Trinity Desktop Environment - a computer desktop environment for Unix-like operating systems with a primary goal of retaining the function and form of traditional desktop computers.


notanos

EDE

  • EDE - light and fast desktop environment - small desktop environment built to be responsive, light in resource usage and to have familiar look and feel. It runs on Linux, *BSD, Solaris, Minix, Zaurus and even on XBox.

Pantheon

Budgie Desktop

OS.js

  • OS.js - JavaScript Cloud/Web Desktop Platform [18]

Lu,ia

XDE

Modular DE for non-DE window managers?

System GUI

Status bar

usually fairly minimal

dzen

bar

some_sorta_bar

  • some_sorta_bar - A simple bar to display text from a pipe for lightweight window managers. e.g; conky | some_sorta_bar

xmobar

  • xmobar is a minimalistic, mostly text based, status bar. It was originally designed and implemented by Andrea Rossato to work with xmonad, but it's actually usable with any window-manager. xmobar was inspired by the Ion3 status bar, and supports similar features, like dynamic color management, icons, output templates, and extensibility through plugins.

taffybar

  • taffybar - A somewhat fancier desktop bar than xmobar. This bar is based on gtk2hs and provides several widgets (including a few graphical ones). It also sports an optional snazzy system tray. haskell

gobar

goi3bar

bipolarbar

bevelbar

j4-status

n30f

  • https://github.com/sdhand/n30f - a quick hack to display a png in a borderless and transparent non-wm-managed window build using make and install to $PREFIX (/usr by default) with sudo make install

lolstat

polybar

Yabar

Panel / Taskbar

  • tint2 is a simple panel/taskbar made for modern X window managers. It was specifically made for Openbox but it should also work with other window managers (GNOME, KDE, XFCE etc.). Panel with taskbar, system tray, clock and launcher icons; Easy to customize: color/transparency on fonts, icons, borders and backgrounds; Pager like capability: move tasks between workspaces (virtual desktops), switch between workspaces; Multi-monitor capability: create one panel per monitor, showing only the tasks from the current monitor; Customizable mouse events. fork of ttm.





  • http://freecode.com/projects/hpanel - Hpanel is hacked version of fspanel, a small panel that lists your windows and allows you to switch workspaces. It requires a window manager that is compliant with the NETWM specification. It works nicely with pekwm and aewm++, and handles maximized windows better than fspanel.



  • Glx-Dock / Cairo-Dock a desktop interface that takes the shape of docks, desklets, panel, etc. It is designed to be light, fast and customizable, and is desktop-agnostic. It has a powerful DBus interface, to be controlled from a terminal or another application. Features can be added by plug-ins or applets, and applets can be written in C or in any language.

Most actions can be done from keyboard.

  • Plank is meant to be the simplest dock on the planet.


System tray

Dock


  • xdock - emulates the Window Maker docks, with the following differences: runs in any window manager; client/server - it works in a client/server way, where a server sits in the right side of the screen, and the docks are clients that connect to that server; easy to program - programming the Window Maker docks was a hard job. But xdock provides a API that makes programming much easier!
  • Flipse - small app that collects Windowmaker Dockapps into one window. This allows the usage of WM Dockapps in other Windowmanagers like wmii.Code is heavily inspired by XFCE-WMDock
  • BBDock - an application launcher for Blackbox-like window manager that allows you to create application buttons in the slit/dock. It works with PNG files rather than XPM images. It supports alpha blending at 16, 24 and 32 bits color-depth. Also, the raise-window function is available to window managers which implement the EWMH specification. See the README for more details.



  • Docker is a docking application (WindowMaker dock app) which acts as a system tray for KDE and GNOME2. It can be used to replace the panel in either environment, allowing you to have a system tray without running the KDE/GNOME panel or environment.
  • wmDrawer is a dock application (dockapp) which provides a drawer (retractable button bar) to launch applications.




  • simdock - an eye-candy deskbar for Linux. a lightweight Dock launcher for common Applications. Docklight” is a simple but effective dock launcher for GNOME desktops e.g (gnome, cinnamon, mate etc.). It supports a Preview from all open Applications. The “Docklight” preview allows more control over the opened windows. You can navigate to a specific window much easier. Select the window or close the desired application the real time preview make that very easy. “Docklight” is written in C++ with “GTK 3” and “libwnck”. “Docklight” is open source width a GNU General Public License.

Menu launchers

dmenu

dmenu -h 17 -fn '-*-terminus-medium-*-*-*-16-*-*-*-*-*-*-*' -nb '#000000' -nf '#c5c5c5' -sb '#4f2877' -sf '#ffffff' -dim 0.4 -dc '#485D00'



forks;

  • dmenu2 is the fork of original dmenu - an efficient dynamic menu for X, patched with XFT, quiet, x & y, token, fuzzy matching, follow focus, tab nav, filter. Added option to set screen on which dmenu apperars, as long as opacity, window class and window name. Also allows to dim screen with selected color and opacity while dmenu2 is running. Added underline color and height. (options -uc and -uh)


wrappers;






tmenu

  • https://github.com/dhamidi/tmenu - a dynamic menu for tty devices, which reads a list of newline-separated items from stdin. When the user selects an item and presses Return, the selected item is printed to stdout. Entering text will narrow the list of items to items that contain the entered text.

slmenu

percol


other



Taskbar launcher

  • Gtk Menu - Standalone - a Gtk2 standalone applications menu written in C for Unix-like (Linux, *BSD) operating systems. It can be run by your favorite launcher (bbbutton, fluxbox menu, with a hotkey app/binding, etc). This menu always shows the latest installed applications that have .desktop entries in the user and system applications directories.
  • https://sites.google.com/site/jvinla/mygtkmenu - When myGtkMenu is executed (by clicking on a panel or desktop icon), it reads a text file and creates a menu. The order of the menu items, which icons are used, and the commands to be executed are specified in the text file. You control the text file. Indeed, if you wanted, you could have ten icons associated with ten (different) custom menus. Re installing just involves backing up and restoring the menu files and associating a panel icon with each custom menu. If you put myGtkMenu and the custom menu-description file(s) in a single directory, it is very fast and easy to backup and restore everything.


Popup launcher


  • Launchy - a free cross-platform utility designed to help you forget about your start menu, the icons on your desktop, and even your file manager. Launchy indexes the programs in your start menu and can launch your documents, project files, folders, and bookmarks with just a few keystrokes!



  • Kupfer - an interface for quick and convenient access to applications and their documents. The most typical use is to find a specific application and launch it. We have tried to make Kupfer easy to extend with plugins so that this quick-access paradigm can be extended to many more objects than just applications.


  • https://wiki.gnome.org/Projects/GnomeLaunchBox - Launch Box is generally an application launcher. It's very influenced by Quicksilver for Mac OSX. It is written for the GNOME 2.10 or newer platform and depends on GTK+ 2.6 or newer, evolution-data-server 1.2 or newer and gnome-menus. These are currently hard dependencies but the plan is to split out the backends into different optional backends. Currently supported modules are:


  • Gnome-Pie - a circular application launcher (pie menu) for Linux. It is made of several pies, each consisting of multiple slices. The user presses a key stroke which opens the desired pie. By activating one of its slices, applications may be launched, key presses may be simulated or files can be opened.
  • bashrun2 - an application launcher based on a modified bash session in a small terminal window, providing all the well known bash features like tab-completion and history. Additional features include automatic detection of console applications, rules for running console applications in dedicated terminals, running commands with a different user id, regexp based command line rewriting (file associations, web shortcuts, etc), user-defined actions and extensions, remote control features, and more.
  • https://github.com/ManuelSchneid3r/albert - a desktop agnostic launcher. Its goals are usability and beauty, performance and extensibility. It is written in C++ and based on the Qt framework. Access everything with virtually zero effort. Run applications, open files or their paths, open bookmarks in your browser, search the web, calculate things and a lot more …
  • Albert - Access everything with virtually zero effort. Run applications, open files or their paths, open bookmarks in your browser, search the web, calculate things and a lot more. See the docs for more information.
  • CmdLauncher - Aimed at helping people use command line tools in a GUI way. CmdLauncher provides a simple way for developers to make their console programs launch by selecting one from the list, or choosing a file, or something else which could be done easily by people who are not experts. What the command line program developers need to do is to write a simple yaml format file containing information of their command line programs, which will be read by CmdLauncher.
  • Cerebro App - open-source productivity booster with a brain. Search everything in few clicks. On your machine or in the Internet. Interact with everything: open file in default program or reveal in finder, copy contact details to clipboard, see google suggestions. Maps, translations, files. Now you don’t have to open another application to see what you need. Everything is in one place. Using included plugin manager you always can find and use what you want. There is no plugin that you are looking for? Use simple, but powerful API to build your own plugins and share them with community. Cerebro is free and open-source.
  • xlunch - the coolest graphical app launcher for Xorg/X11. It requires only pure Xlib and Imlib2. It allows you to run programs, commands, or simply select something out of a list using your mouse, keyboard, or both! UTF8 is fully supported meaning you can have text of all kinds. The prompt allows you to run arbitrary commands, and it works to filter your entries as well. xlunch is also highly configurable, both in functionality and style, it can even be used as a desktop!

Fullscreen launcher

  • Homerun - a fullscreen launcher with content organized in tabs. A tab is composed of several "sources". A source can provide one or more sections to a tab. Homerun comes with a few built-in sources, but custom sources can be written using libhomerun.
  • https://github.com/echo-devim/RapidLauncher - an application launcher that is supposed to be fast and relatively lightweight. The backend is written in Vala and the frontend is written with C/GTK+ 3. Rapid Launcher is born to give a good launcher also for old PCs. It's really simple and is inspired by the Android and OSX launchers.

to sort



  • xfce4-appfinder - a tool to find and launch installed applications on your system and the quickly execute commands. It can also be used to quickly add launchers to the Xfce Panel by dragging an item from the view and drop it on the panel.]


  • Services menu - an application that helps the user perform actions on text in other programs. The user simply selects some text and launches Services — for example, by keyboard shortcut or clicking the fourth mouse button. A menu pops up letting the user edit the text and select desired operation, such as open a browser window searching for the text in Google.


  • Slingshot - lightweight and stylish app launcher from elementary OS.


  • thinglaunch - a launcher program for X. You can bind it to a key in your favorite window manager, and when you want to start a program, just type its name. thinglaunch has a tiny footprint and depends only on Xlib.


Task switcher


  • SuperSwitcher is a (more feature-ful) replacement for the Alt-Tab window switching behavior and Ctrl-Alt-Left/Right/Up/Down workspace switching behavior that is currently provided by Metacity. When running, use the 'Super' key (also known as the 'Windows' key) to switch between windows and workspaces. This key is usually found between the Ctrl and Alt keys on the keyboard.


  • Rofi - A popup window switcher roughly based on superswitcher, requiring only xlib and pango. This version started off as a clone of simpleswitcher, the version from Sean Pringle. All credit for this great tool should go to him. Rofi developed extra features, like a run-dialog, ssh-launcher and can act as a drop-in dmenu replacement, making it a very versatile tool.


Virtual desktop pagers


  • multihead size problem A = virtual desktop representation size matches viewport size, but within that, the viewport representation is false, squeezing in a non-existent viewport for the opposite monitor.
  • multihead size problem B = virtual desktop representation size does not match viewport site, instead being double the actual viewport by including the width of the non-existent opposite monitor

Setup is with randr 1.2+ multihead. I think this is due to a lack of EWMH support in bspwm.


  • http://www.makelinux.com/man/1/B/bbpager - blackbox
    • multihead size problem A(+B)
    • desktop representations are correct width ratio, but it just hides the right hand side, i.e, second monitor windows are essentially hidden



  • https://github.com/ijanos/desktend - automatic virtual desktop extender. update the number of virtual desktops of EWMH compatible X11 window managers. add a new virtual desktop to the right every time there is a new window appears on the last desktop.




Task manager

Infos

  • lshw-gtk

Conky

Notifications




Widgets

Desktop icons

  • Idesk - gives users of minimal wm's (fluxbox, pekwm, windowmaker...) icons on their desktop. The icon graphics are either from a png or svg (vector) file and support some eyecandy effects like transparency. Each icon can be confgured to run one or more shell commands and the actions which run those commands are completely configurable. In a nutshell if you want icons on your desktop and you don't have or dont't want KDE or gnome doing it, you can use idesk.
  • IconMgr - a manager of desktop icons, Features include configurable actions to run shell commands. It has support for imlib2.
  • DFM - a file manager for Linux and other UNIX like Operating Systems. DFM is the abrvabation for Desktop File Manager. "Desktop" stands for the capability to place icons on the root window. The idea to write DFM came from OS/2. For a long time I had worked with OS/2. Using Linux I miss a desktop that provides easy launching programs, managing files and their association. I think only a program like the WPS can provide this.

On Screen Display

  • ghosd -- on-screen display (osd) with transparency

Volume

other

  • fsv (pronounced eff-ess-vee) is a file system visualizer in cyberspace. It lays out files and directories in three dimensions, geometrically representing the file system hierarchy to allow visual overview and analysis. fsv can visualize a modest home directory, a workstation's hard drive, or any arbitrarily large collection of files, limited only by the host computer's memory and graphics hardware. "i know this!"

Tiling

For non tiling WMs

  • Wumwum is a window manager manager. It manages window managers so that they place your windows automatically the way a tile-based window manager (ion or awesome) would do it. This way you get the nice graphics of modern window managers and the efficiency of keyboard driven tiling-based managers. Moreover you can still use all features of the underlying manager and you keep all your keyboard shortcuts and behaviour when switching from one manager to the other.

Screensaver and locks

  • XScreenSaver is the standard screen saver collection shipped on most Linux and Unix systems running the X11 Window System. I released the first version in 1992. I ported it to MacOS X in 2006, and to iOS in 2012. On X11 systems, XScreenSaver is two things: it is both a large collection of screen savers; and it is also the framework for blanking and locking the screen.




  • https://github.com/the-cavalry/light-locker a simple locker (forked from gnome-screensaver) that aims to have simple, sane, secure defaults and be well integrated with the desktop while not carrying any desktop-specific dependencies.

It relies on lightdm for locking and unlocking your session via ConsoleKit/UPower or logind/systemd.

Screenshot

scrot mydesktop.png

scrot '%Y-%m-%d_$wx$h.png' -e 'mv $f ~/documents/images/screenshots/'
  would create a file called something like 2000-10-30_2560x1024.png in a screenshots directory.
import -window root Pictures/Image5.png
  imagemagick

Colour

Widget toolkits

  • Survey of Widget Sets - This page serves as a survey of the various free widget sets written for the X intrinsics. Most of these widget sets are variations on the standard Athena widget set, Xaw.


  • https://wiki.archlinux.org/index.php/Uniform_Look_for_Qt_and_GTK_Applications - Qt and GTK+ based programs both use a different widget toolkit to render the graphical user interface. Each come with different themes, styles and icon sets by default, among other things, so the "look and feel" differ significantly. This article will help you make your Qt and GTK+ applications look similar for a more streamlined and integrated desktop experience.

qt5-styleplugins - QGtkStyle - This Qt style uses GTK+ 2 to render all components to blend in with GNOME and similar GTK+ based environments. Beginning with Qt 4.5, this style is included in Qt. It requires gtk2 to be installed and configured.

find $(find ~/.themes /usr/share/themes/ -wholename "*/gtk-3.0" | sed -e "s/^\(.*\)\/gtk-3.0$/\1/") -wholename "*/gtk-2.0" | sed -e "s/.*\/\(.*\)\/gtk-2.0/\1"/
  # find gtk/gtk3 themes

Good GTK2/GTK3 themes

  • ....

Xt

  • https://en.wikipedia.org/wiki/X_Toolkit_Intrinsics - also known as Xt, for X toolkit) is a library that implements an API to facilitate the development of programs with a graphical user interface (GUI) for the X Window System. It can be used in the C or C++ languages.

Most modern toolkits such as FLTK, GTK+, and Qt do not use the Xt library, preferring to use Xlib or even XCB directly.

Athena (Xaw)

OPEN LOOK (XView)

Sun Solaris

Motif (Xm)

Tk

1991

FLTK

1992

wxWidgets

1992

EFL

GTK+

Used by GNOME

  • libwnck is the Window Navigator Construction Kit, a library for use in writing pagers, tasklists, and more generally applications that are dealing with window management. It tries hard to respect the Extended Window Manager Hints specification (EWMH). The Inter-Client Communication Conventions Manual (ICCCM) is also a useful resource.

GTK2 theming

Tools
  • Zenity is a tool that allows you to display Gtk+ dialog boxes from the command line and through shell scripts. It is similar to gdialog, but is intended to be saner. It comes from the same family as dialog, Xdialog, and cdialog, but it surpasses those projects by having a cooler name.
  • GtkOrphan (a Perl/Gtk2 application for debian systems) is a graphical tool which analyzes the status of your installations, looking for orphaned libraries. It implements a GUI front-end for deborphan, adding the package-removal capability.

GTK3 theming

Clutter

Qt

qtconfig qt4

GDK

  • https://en.wikipedia.org/wiki/GDK - GIMP Drawing Kit, a library that acts as a wrapper around the low-level functions provided by the underlying windowing and graphics systems. GDK lies between the display server and the GTK+ library, handling basic rendering such as drawing primitives, raster graphics (bitmaps), cursors, fonts, as well as window events and drag-and-drop functionality.

SDL

GVL

libui

Nuklear

  • https://github.com/vurtun/nuklear - a minimal state immediate mode graphical user interface toolkit written in ANSI C and licensed under public domain. It was designed as a simple embeddable user interface for application and does not have any dependencies, a default renderbackend or OS window and input handling but instead provides a very modular library approach by using simple input state for input and draw commands describing primitive shapes as output. So instead of providing a layered library that tries to abstract over a number of platform and render backends it only focuses on the actual UI.

Dear ImGui

yue

Configuration



  • https://github.com/derat/xsettingsd - a daemon that implements the XSETTINGS specification. It is intended to be small, fast, and minimally dependent on other libraries. It can serve as an alternative to gnome-settings-daemon for users who are not using the GNOME desktop environment but who still run GTK+ applications and want to configure things such as themes, font antialiasing/hinting, and UI sound effects.


Desktop/menu files

X terminals

See also *nix#Terminal_.2F_console

Xterm

  • How to change the title of an xterm - This document explains how to use escape sequences to dynamically change window and icon titles of an xterm. Examples are given for several shells, and the appendix gives escape sequences for some other terminal types.



urxvt

if not using a tiling window manager, tabbed is good + remote tmux. urxvt has overhead because of unicode.

urxvt sets char width as widest char in font. there's a patched package for that.

urxvt -e sh -c "ls && zsh"
  # launch command then exit to zsh [25]


urxvtd -q -f -o
urxvtc -e command

.Xresources / .Xdefaults config:

URxvt.keysym.Shift-Up: command:\033]720;1\007
URxvt.keysym.Shift-Down: command:\033]721;1\007
  # adds single line scroll-back [26]



The default perl set includes the "selection", "option-popup", "selection-popup", "readline" and "searchable-scrollback" extensions, and extensions which are mentioned in keysym resources.

  • Arch Forum: [Solved Change urxvt's font on the fly: Can YOU do it?]
 printf '\33]50;%s\007' "xft:Terminus:pixelsize=16"


st

-*-terminus-medium-r-*-*-10-*-*-*-*-*-*-*

vte

  • https://github.com/GNOME/vte - VTE is a library (libvte) implementing a terminal emulator widget for GTK+, and a minimal sample application (vte) using that. Vte is mainly used in gnome-terminal, but can also be used to embed a console/terminal in games, editors, IDEs, etc.

Other

  • mlterm - a multi-lingual terminal emulator , which supports various character sets and encodings in the world.
  • LilyTerm is a terminal emulator based off of libvte that aims to be fast and lightweight, Licensed under GPLv3.
  • termite - A keyboard-centric VTE-based terminal, aimed at use within a window manager with tiling and/or tabbing support.
  • sakura - a terminal emulator based on GTK and libvte. It has few dependencies, so there's no need of a full GNOME desktop installed to have a powerful terminal emulator. sakura uses a gtk notebook to provide tabbed terminals in one window and has a contextual menu for configuration; it was designed without a menu bar. No more no less.


  • Final Term is a new breed of terminal emulator. It goes beyond mere emulation and understands what is happening inside the shell it is hosting. This allows it to offer features no other terminal can, including: Semantic text menus, Smart command completion, GUI terminal controls [27]
  • HTerm - A graphical terminal requiring no serverside support. [28]

Retro;

/usr/lib/xscreensaver/apple2 -text -fast -program bash
  • cool-retro-term is a terminal emulator which mimics the look and feel of the old cathode tube screens. It has been designed to be eye-candy, customizable, and reasonably lightweight. It uses the Konsole engine which is powerful and mature. This terminal emulator requires Qt 5.2 or higher to run.


  • Nixar - Joyable equivalents for existent linux commands
  • https://launchpad.net/terra Terra is a GTK+3.0 based terminal emulator with useful user interface, it also supports multiple terminals with splitting screen horizontally or vertically. New features will be added soon. It's very new and experimental project, if you want to contribute just checkout and try.



  • https://github.com/withoutboats/notty - a virtual terminal like xterm, gnome-vte, sh, or rxvt. Unlike these programs, notty is not intended to emulate a DEC VT-series physical video terminal, or any other physical device. Instead, notty is an experimental project to bring new features to the command-line which would not have been possible for the physical terminals other terminals emulate. [30]
  • https://github.com/jwilm/alacritty - Alacritty is the fastest terminal emulator in existence. Using the GPU for rendering enables optimizations that simply aren't possible in other emulators. Alacritty currently supports macOS and Linux, and Windows support is planned before the 1.0 release.


  • https://github.com/vshatskyi/black-screen - an IDE in the world of terminals. Strictly speaking, it's both a terminal emulator and an interactive shell based on Electron. Also, unlike most of the emulators you can meet nowadays it uses HTML and CSS for its UI (exactly as Atom does), which means we can stop misusing unicode characters and make a better looking terminal with appropriate tools. [31]



Dropdown

Web

  • FireSSH is a free, cross-platform SSH terminal client for Mozilla Firefox and Google Chrome. Written entirely in Javascript!
  • KeyBox - A web-based SSH console that executes commands on multiple shells. KeyBox allows you to manage keys, share terminal commands, and upload files to multiple systems simultaneously. [32]
  • oterm is a web browser unix terminal. It serves a console so you can access your server from anywhere in the world where you have an Internet connection. It effectively is an xterm in a browser. [33]

Text-based user interface

File managers

Dolphin

PCManFM

SpaceFM

qtFM

Sunflower

Thunar

XFE

Pantheon Files


fman

Double Commander

muCommander

  • muCommander - a lightweight, cross-platform file manager with a dual-pane interface. It runs on any operating system with Java support (Mac OS X, Windows, Linux, *BSD, Solaris...).

Vifm

  • Vifm - a file manager with curses interface, which provides Vi[m]-like environment for managing objects within file systems, extended with some useful ideas from mutt. If you use vi, Vifm gives you complete keyboard control over your files without having to learn a new set of commands.

emelFM2

https://en.wikipedia.org/wiki/emelFM2

gentoo


Synkron

File system inspection

  • QDirStat - Qt-based directory statistics (KDirStat without any KDE - from the original KDirStat author)


  • K4DirStat - (KDE Directory Statistics) is a small utility program that sums up disk usage for directory trees, very much like the Unix 'du' command. It displays the disk space used up by a directory tree, both numerically and graphically (copied from the Debian package description). v2 required KDE 5.


  • http://www.chiark.greenend.org.uk/~sgtatham/agedu/ agedu - disk scan like du but that also records the last-access times of everything it scans. Then it builds an index that lets it efficiently generate reports giving a summary of the results for each subdirectory, and then it produces those reports on demand.
  • xdu


Compression

Screen magnification




  • kmag

Multitouch

  • TUIO is an open framework that defines a common protocol and API for tangible multitouch surfaces. The TUIO protocol allows the transmission of an abstract description of interactive surfaces, including touch events and tangible object states. This protocol encodes control data from a tracker application (e.g. based on computer vision) and sends it to any client application that is capable of decoding the protocol. There exists a growing number of TUIO enabled tracker applications and TUIO client libraries for various programming environments, as well as applications that support the protocol.
  • Glassomium - Open-source cross-platform web-based TUIO-enabled multi-touch window manager
  • reacTIVision is an open source, cross-platform computer vision framework for the fast and robust tracking of fiducial markers attached onto physical objects, as well as for multi-touch finger tracking. It was mainly designed as a toolkit for the rapid development of table-based tangible user interfaces (TUI) and multi-touch interactive surfaces.


  • The Natural User Interface Group is an open source community that creates and shares interaction techniques & standards that benefit designers & developers throughout the world. We offer a collaborative environment for scientists that are interested in learning and developing modern Human/Computer Interaction methods and concepts. Our research includes topics such as: computer vision, touch computing, voice & gesture recognition, experience design and information visualization.

Remote

3D

History

other

Calculator

Clipboard

Selecting any text in Linux copies it and scroll-wheel middle click pastes it, separate to the Ctrl-c Ctrl-v clipboard. This means double clicking a non-line broke sentence copies it to the middle click paste clipboard.

This most used selection is the PRIMARY selection, and is used when the user selects some data. The CLIPBOARD selection is used when the user selects some data and explicitly requests it to be "copied" to the clipboard, such as by invoking "Copy" under the "Edit" menu of an application. An associated request of "Paste" results in the data of the CLIPBOARD selection being used.

"The PRIMARY selection is used when you select some text with the mouse. You usually paste it using the middle button. The CLIPBOARD selection is used when you copy text by using, for example, the Edit/Copy menu. You may paste it using the Edit/Paste menu."

Shift-Insert
  paste PRIMARY selection (where ctrl-v isn't supported)
Ctrl-v
  pate CLIPBOARD selection

Articles

Software

xclip

  • xclip is a command line interface to the X11 clipboard. It can also be used for copying files, as an alternative to sftp/scp, thus avoiding password prompts when X11 forwarding has already been setup.

Autocutsel

  • Autocutsel tracks changes in the server's cutbuffer and CLIPBOARD selection. When the CLIPBOARD is changed, it updates the cutbuffer. When the cutbuffer is changed, it owns the CLIPBOARD selection. The cutbuffer and CLIPBOARD selection are always synchronized. Since the VNC client synchronizes the Windows' clipboard and the server's cutbuffer, all three "clipboards" are always kept synchronized.

xcmenu

XSel

  • XSel - a command-line program for getting and setting the contents of the X selection. Normally this is only accessible by manually highlighting information and pasting it with the middle mouse button.

CopyQ

  • CopyQ is clipboard manager with searchable and editable history.

Parcellite

  • Parcellite is a lightweight GTK+ clipboard manager. This is a stripped down, basic-features-only clipboard manager with a small memory footprint for those who like simplicity.

Other

Wayland

  • Wayland is intended as a simpler replacement for X, easier to develop and maintain. GNOME and KDE are expected to be ported to it. Wayland is a protocol for a compositor to talk to its clients as well as a C library implementation of that protocol. The compositor can be a standalone display server running on Linux kernel modesetting and evdev input devices, an X application, or a wayland client itself. The clients can be traditional applications, X servers (rootless or fullscreen) or other display servers.

Part of the Wayland project is also the Weston reference implementation of a Wayland compositor. Weston can run as an X client or under Linux KMS and ships with a few demo clients. The Weston compositor is a minimal and fast compositor and is suitable for many embedded and mobile use cases.


sway



Mir


Arcan

  • Arcan - Arcan is a powerful development framework for creating virtually anything between user interfaces for specialised embedded applications all the way to full-blown standalone desktop environments. Boot splash screen? no problem. SCADA HMI for your home? easy peasy. Xorg backend? got you covered. Wayland compositor? sure thing. At its heart lies a robust and portable multimedia engine, with a well-tested and well-documented interface, programmable using Lua. At every step of the way, the underlying development emphasises security, performance and debugability guided by a principle of least surprise in terms of API design.
  • Durden - a desktop environment for the Arcan Display Server. It serves both as a reference showcase on how to take advantage of some of the features in Arcan, and as a very competent entry to the advanced-user side of the desktop environment spectrum. The basic premise is to absorb most, if not all, features from current desktop environments in a modular and configurable way - then let user selected profiles actually cherry- pick the configuration, visuals and tunning that reflects the desktop the user wants or is familiar with. Internally, it is based around a file-system like structure ("the menu") and everything else is references to paths within this structure. Development is discussed on IRC @ irc.freenode.net, #arcan - while issues are tracked at the github page for now.