Window Manager 1 0 5

1. Window Manager 1 0 5 Pc Game Full
2. Window Manager 1 0 5 Key
3. Window Manager 1 0 5 9
4. 1 0 Math

Creates a new top-level window. More..

Fluxbox — Window manager for X that was based on the Blackbox 0.61.1 code. It is very light on resources and easy to handle but yet full of features to make an easy and extremely fast desktop experience. It is built using C and licensed under the MIT License. Each window manager provides a different look and feel: some support virtual desktops, some allow customized keystrokes to manage the desktop, some have a 'Start' button, and some are themeable, allowing a complete change of the desktop's look-and-feel. Window managers are available in the x11-wm category of the Ports Collection. XDMCP, twm (from the beginning known as Tom's window manager) brought in as standard window manager, application improvements, shape extension, new fonts. X11R5 5 September 1991: X386 1.2, PEX, Xcms (color management), font server, X video extension. X11R6 16 May 1994. Aug 27, 2021 Advanced Download Manager Pro 12.5.4 Apk + Mod for Android. Powerful Downloader: downloading from internet up to three files simultaneously; accelerated downloading by using multithreading (9 parts). Discussion how to fix window boot manager has been blocked by the current security policy on acerv5window 8.1 Author Date within 1 day 3 days 1 week 2 weeks 1 month 2 months 6 months 1 year of Examples: Monday, today, last week, Mar 26, 3/26/04.

Properties

• active : bool
• activeFocusItem : Item
• color : color
• contentItem : Item
• contentOrientation : Qt::ScreenOrientation
• data : list
• flags : Qt::WindowFlags
• height : int
• maximumHeight : int
• maximumWidth : int
• minimumHeight : int
• minimumWidth : int
• modality : Qt::WindowModality
• opacity : real
• screen : variant
• title : string
• transientParent : QWindow
• visibility : QWindow::Visibility
• visible : bool
• width : int
• x : int
• y : int

Attached Properties

• active : bool
• activeFocusItem : Item
• contentItem : Item
• height : int
• visibility : QWindow::Visibility
• width : int
• window : Window

Signals

• afterAnimating()
• closing(CloseEvent close)
• frameSwapped()
• sceneGraphError(SceneGraphError error, QString message)

Methods

• alert(int msec)
• close()
• hide()
• lower()
• raise()
• requestActivate()
• show()
• showFullScreen()
• showMaximized()
• showMinimized()
• showNormal()

Detailed Description

The Window object creates a new top-level window for a Qt Quick scene. It automatically sets up the window for use with QtQuick 2.x graphical types.

To use this type, you will need to import the module with the following line:

Omitting this import will allow you to have a QML environment without access to window system features.

A Window can be declared inside an Item or inside another Window; in that case the inner Window will automatically become 'transient for' the outer Window: that is, most platforms will show it centered upon the outer window by default, and there may be other platform-dependent behaviors, depending also on the flags. If the nested window is intended to be a dialog in your application, you should also set flags to Qt.Dialog, because some window managers will not provide the centering behavior without that flag. You can also declare multiple windows inside a top-level QtObject, in which case the windows will have no transient relationship.

Alternatively you can set or bind x and y to position the Window explicitly on the screen.

When the user attempts to close a window, the closing signal will be emitted. You can force the window to stay open (for example to prompt the user to save changes) by writing an onClosing handler and setting close.accepted = false.

Property Documentation

Defines the window's maximum size.

This is a hint to the window manager to prevent resizing above the specified width and height.

This QML property was introduced in Qt 5.1.




Defines the window's minimum size.

This is a hint to the window manager to prevent resizing below the specified width and height.

This QML property was introduced in Qt 5.1.




Defines the window's position and size.

The (x,y) position is relative to the Screen if there is only one, or to the virtual desktop (arrangement of multiple screens).




The active status of the window.

Window Manager 1 0 5 Pc Game Full

This property was introduced in Qt 5.1.

See also requestActivate().




The item which currently has active focus or null if there is no item with active focus.

This property was introduced in Qt 5.1.




The background color for the window.

Setting this property is more efficient than using a separate Rectangle.




The invisible root item of the scene.




This is a hint to the window manager in case it needs to display additional content like popups, dialogs, status bars, or similar in relation to the window.

The recommended orientation is Screen.orientation, but an application doesn't have to support all possible orientations, and thus can opt to ignore the current screen orientation.

The difference between the window and the content orientation determines how much to rotate the content by.

The default value is Qt::PrimaryOrientation.

This property was introduced in Qt 5.1.

See also Screen.




The data property allows you to freely mix visual children, resources and other Windows in a Window. Soundsource 4 2 16.

If you assign another Window to the data list, the nested window will become 'transient for' the outer Window.

If you assign an Item to the data list, it becomes a child of the Window's contentItem, so that it appears inside the window. The item's parent will be the window's contentItem, which is the root of the Item ownership tree within that Window.

If you assign any other object type, it is added as a resource.

It should not generally be necessary to refer to the data property, as it is the default property for Window and thus all child items are automatically assigned to this property.

See also QWindow::transientParent().




The window flags of the window.

The window flags control the window's appearance in the windowing system, whether it's a dialog, popup, or a regular window, and whether it should have a title bar, etc.

The flags which you read from this property might differ from the ones that you set if the requested flags could not be fulfilled.

See also Qt::WindowFlags.




The modality of the window.

A modal window prevents other windows from receiving input events. Possible values are Qt.NonModal (the default), Qt.WindowModal, and Qt.ApplicationModal.




The opacity of the window.

If the windowing system supports window opacity, this can be used to fade the window in and out, or to make it semitransparent.

A value of 1.0 or above is treated as fully opaque, whereas a value of 0.0 or below is treated as fully transparent. Values inbetween represent varying levels of translucency between the two extremes.

The default value is 1.0.

This property was introduced in Qt 5.1.




The screen with which the window is associated.

If specified before showing a window, will result in the window being shown on that screen, unless an explicit window position has been set. The value must be an element from the Qt.application.screens array.

Note: To ensure that the window is associated with the desired screen when the underlying native window is created, make sure this property is set as early as possible and that the setting of its value is not deferred. This can be particularly important on embedded platforms without a windowing system, where only one window per screen is allowed at a time. Setting the screen after a window has been created does not move the window if the new screen is part of the same virtual desktop as the old screen.

This property was introduced in Qt 5.9.

See also QWindow::setScreen(), QWindow::screen(), QScreen, and Qt.application.




The window's title in the windowing system.

The window title might appear in the title area of the window decorations, depending on the windowing system and the window flags. It might also be used by the windowing system to identify the window in other contexts, such as in the task switcher.




The window for which this window is a transient pop-up.

This is a hint to the window manager that this window is a dialog or pop-up on behalf of the transient parent. It usually means that the transient window will be centered over its transient parent when it is initially shown, that minimizing the parent window will also minimize the transient window, and so on; however results vary somewhat from platform to platform.

Normally if you declare a Window inside an Item or inside another Window, this relationship is deduced automatically. In that case, if you declare this window's visible property true, it will not actually be shown until the transientParent window is shown.

However if you set this property, then Qt Quick will no longer wait until the transientParent window is shown before showing this window. If you want to to be able to show a transient window independently of the 'parent' Item or Window within which it was declared, you can remove that relationship by setting transientParent to null:

In order to cause the window to be centered above its transient parent by default, depending on the window manager, it may also be necessary to set the Window::flags property with a suitable Qt::WindowType (such as Qt::Dialog).

This property was introduced in Qt 5.13.




The screen-occupation state of the window.

Visibility is whether the window should appear in the windowing system as normal, minimized, maximized, fullscreen or hidden.

To set the visibility to AutomaticVisibility means to give the window a default visible state, which might be FullScreen or Windowed depending on the platform. However when reading the visibility property you will always get the actual state, never AutomaticVisibility.

When a window is not visible its visibility is Hidden, and setting visibility to Hidden is the same as setting visible to false.

This property was introduced in Qt 5.1.

See also visible.




Whether the window is visible on the screen.

Setting visible to false is the same as setting visibility to Hidden.

See also visibility.




Attached Property Documentation

These attached properties hold the size of the item's window. The Window attached property can be attached to any Item.

This QML property was introduced in Qt 5.5.




This attached property tells whether the window is active. The Window attached property can be attached to any Item.

Here is an example which changes a label to show the active state of the window in which it is shown:

This property was introduced in Qt 5.4.




This attached property holds the item which currently has active focus or null if there is no item with active focus. The Window attached property can be attached to any Item.

This property was introduced in Qt 5.4.

This attached property holds the invisible root item of the scene or null if the item is not in a window. The Window attached property can be attached to any Item.

This property was introduced in Qt 5.4.

This attached property holds whether the window is currently shown in the windowing system as normal, minimized, maximized, fullscreen or hidden. The Window attached property can be attached to any Item. If the item is not shown in any window, the value will be Hidden.

This property was introduced in Qt 5.4.

See also visible and visibility.

This attached property holds the item's window. The Window attached property can be attached to any Item.

This property was introduced in Qt 5.7.

Signal Documentation

This attached property holds the invisible root item of the scene or null if the item is not in a window. The Window attached property can be attached to any Item.

This property was introduced in Qt 5.4.

This attached property holds whether the window is currently shown in the windowing system as normal, minimized, maximized, fullscreen or hidden. The Window attached property can be attached to any Item. If the item is not shown in any window, the value will be Hidden.

This property was introduced in Qt 5.4.

See also visible and visibility.

This attached property holds the item's window. The Window attached property can be attached to any Item.

This property was introduced in Qt 5.7.

Signal Documentation

This signal is emitted on the GUI thread before requesting the render thread to perform the synchronization of the scene graph.

You can implement onAfterAnimating to do additional processing after each animation step.

Note: The corresponding handler is onAfterAnimating.

This signal was introduced in Qt 5.3.

This signal is emitted when the user tries to close the window.

This signal includes a close parameter. The close.accepted property is true by default so that the window is allowed to close; but you can implement an onClosing handler and set close.accepted = false if you need to do something else before the window can be closed.

Note: The corresponding handler is onClosing.

This signal was introduced in Qt 5.1.

This signal is emitted when a frame has been queued for presenting. With vertical synchronization enabled the signal is emitted at most once per vsync interval in a continuously animating scene.

Note: The corresponding handler is onFrameSwapped.

This signal is emitted when an error occurred during scene graph initialization.

You can implement onSceneGraphError(error, message) to handle errors, such as graphics context creation failures, in a custom way. If no handler is connected to this signal, Quick will print the message, or show a message box, and terminate the application.

Note: The corresponding handler is onSceneGraphError.

This signal was introduced in Qt 5.3.

Method Documentation

Causes an alert to be shown for msec milliseconds. If msec is 0 (the default), then the alert is shown indefinitely until the window becomes active again.

In alert state, the window indicates that it demands attention, for example by flashing or bouncing the taskbar entry.

This method was introduced in Qt 5.1.

Closes the window.

When this method is called, or when the user tries to close the window by its title bar button, the closing signal will be emitted. If there is no handler, or the handler does not revoke permission to close, the window will subsequently close. If the QGuiApplication::quitOnLastWindowClosed property is true, and there are no other windows open, the application will quit.

Hides the window.

Equivalent to setting visible to false or visibility to Hidden.

See also show().

Lowers the window in the windowing system.

Requests that the window be lowered to appear below other windows.

Raises the window in the windowing system.

Requests that the window be raised to appear above other windows.

Requests the window to be activated, i.e. receive keyboard focus.

This method was introduced in Qt 5.1.

Shows the window.

This is equivalent to calling showFullScreen(), showMaximized(), or showNormal(), depending on the platform's default behavior for the window type and flags.

See also showFullScreen(), showMaximized(), showNormal(), hide(), and QQuickItem::flags().

Shows the window as fullscreen.

Equivalent to setting visibility to FullScreen.

Shows the window as maximized.

Equivalent to setting visibility to Maximized.

Shows the window as minimized.

Equivalent to setting visibility to Minimized.

Shows the window as normal, i.e. neither maximized, minimized, nor fullscreen.

Equivalent to setting visibility to Windowed.

© 2021 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

A window manager (WM) is system software that controls the placement and appearance of windows within a windowing system in a graphical user interface (GUI). It can be part of a desktop environment (DE) or be used standalone.

Window managers are unique to Xorg. The equivalent of window managers on Wayland are called compositors because they also act as compositing window managers.

Overview

Window managers are X clients that control the appearance and behaviour of the frames ('windows') where the various graphical applications are drawn. They determine the border, title bar, size, and ability to resize windows, and often provide other functionality such as reserved areas for sticking dockapps like Window Maker, or the ability to tab windows like Fluxbox. Some window managers are even bundled with simple utilities like menus to start programs or to configure the window manager itself.

The Extended Window Manager Hints specification is used to allow window managers to interact in standard ways with the server and the other clients.

Some window managers are developed as part of a more comprehensive desktop environment, usually allowing the other provided applications to better interact with each other, giving a more consistent experience to the user, complete with features like desktop icons, fonts, toolbars, wallpapers, or desktop widgets.

Other window managers are instead designed to be used standalone, giving the user complete freedom over the choice of the other applications to be used. This allows the user to create a more lightweight and customized environment, tailored to their own specific needs. 'Extras' like desktop icons, toolbars, wallpapers, or desktop widgets, if needed, will have to be added with additional dedicated applications.

Some standalone window managers can be also used to replace the default window manager of a desktop environment, just like some desktop environment–oriented window managers can be used standalone too.

Prior to installing a window manager, a functional X server installation is required. See Xorg for detailed information.

Types

• Stacking (aka floating) window managers provide the traditional desktop metaphor used in commercial operating systems like Windows and OS X. Windows act like pieces of paper on a desk, and can be stacked on top of each other. For available Arch Wiki pages see Category:Stacking WMs.
• Tiling window managers 'tile' the windows so that none are overlapping. They usually make very extensive use of key-bindings and have less (or no) reliance on the mouse. Tiling window managers may be manual, offer predefined layouts, or both. For available Arch Wiki pages see Category:Tiling WMs.
• Dynamic window managers can dynamically switch between tiling or floating window layout. For available Arch Wiki pages see Category:Dynamic WMs.

See Comparison of tiling window managers and Wikipedia:Comparison of X window managers for comparison of window managers.

List of window managers

Stacking window managers

• 2bwm — Fast floating window manager, with the particularity of having 2 borders, written over the XCB library and derived from mcwm written by Michael Cardell. In 2bwm everything is accessible from the keyboard but a pointing device can be used for move, resize and raise/lower. The name has recently changed from mcwm-beast to 2bwm.

https://github.com/venam/2bwm || 2bwm^AUR

• 9wm — X11 Window Manager inspired by Plan 9's rio.

https://github.com/9wm/9wm || 9wm^AUR

• AfterStep — Window manager for the Unix X Window System. Originally based on the look and feel of the NeXTStep interface, it provides end users with a consistent, clean, and elegant desktop. The goal of AfterStep development is to provide for flexibility of desktop configuration, improving aesthetics, and efficient use of system resources.

http://www.afterstep.org/ || afterstep-git^AUR

• berry — Healthy, bite-sized window manager written in C for Unix systems. It is controlled via a command-line client, allowing users to control windows via a hotkey daemon such as sxhkd or expand functionality via shell scripts. It provides extensible themeing options with double borders, title bars, and window text. Berry intuitively place new windows in unoccupied spaces and supports virtual desktops.

https://berrywm.org/ || berry-git^AUR

• Blackbox — Fast, lightweight window manager for the X Window System, without all those annoying library dependencies. Blackbox is built with C++ and contains completely original code (even though the graphics implementation is similar to that of WindowMaker).

http://blackboxwm.sourceforge.net/ || blackbox

• Compiz — OpenGL compositing manager that uses GLX_EXT_texture_from_pixmap for binding redirected top-level windows to texture objects. It has a flexible plug-in system and it is designed to run well on most graphics hardware.

https://launchpad.net/compiz || compiz^AUR, compiz-core^AUR

• cwm — Originally deriving from evilwm, but later re-written from scratch. cwm aims to be simple, and offers helpful features such as searching for windows.

https://github.com/chneukirchen/cwm || cwm^AUR

• eggwm — A lightweight QT4/QT5 window manager

Window Manager 1 0 5 Key

eggwm-qt5^AUR || eggwm^AUR

• Enlightenment — 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.

https://www.enlightenment.org/ || enlightenment

• evilwm — Minimalist window manager for the X Window System. 'Minimalist' here does not mean it is too bare to be usable - it just means it omits a lot of the stuff that make other window managers unusable.

https://www.6809.org.uk/evilwm/ || evilwm^AUR

• Fluxbox — Window manager for X that was based on the Blackbox 0.61.1 code. It is very light on resources and easy to handle but yet full of features to make an easy and extremely fast desktop experience. It is built using C++ and licensed under the MIT License.

https://github.com/fluxbox/fluxbox || fluxbox

• Flwm — Attempt to combine the best ideas from several window managers. The primary influence and code base is from wm2 by Chris Cannam.

http://flwm.sourceforge.net/ || flwm^AUR

• FVWM — Extremely powerful ICCCM-compliant multiple virtual desktop window manager for the X Window system. Development is active, and support is excellent.

https://www.fvwm.org/ || fvwm^AUR

• Gala — A beautiful Window Manager from elementaryos, part of Pantheon. Also as a compositing manager, based on libmutter.

https://launchpad.net/gala || gala

• Goomwwm — X11 window manager implemented in C as a cleanroom software project. It manages windows in a minimal floating layout, while providing flexible keyboard-driven controls for window switching, sizing, moving, tagging, and tiling. It is also fast, lightweight, modeless, Xinerama-aware, and EWMH compatible wherever possible.

https://github.com/seanpringle/goomwwm || goomwwm^AUR

• IceWM — Window manager for the X Window System. The goal of IceWM is speed, simplicity, and not getting in the user's way.

https://ice-wm.org/ || icewm

• jbwm — jbwm is a window manager based on evilwm, with a minimal configuration size of approximately 16kb, focused on small binary size and usability, incorporating optional title-bars and XFT title-bar font rendering as compile-time options. jbwm also features easier to use keybindings than evilwm.

https://github.com/jefbed/jbwm || jbwm^AUR

• JWM — Window manager for the X11 Window System. JWM is written in C and uses only Xlib at a minimum.

https://joewing.net/projects/jwm/ || jwm

• Karmen — Window manager for X, written by Johan Veenhuizen. It is designed to 'just work.' There is no configuration file and no library dependencies other than Xlib. The input focus model is click-to-focus. Karmen aims at ICCCM and EWMH compliance.

http://karmen.sourceforge.net/ || karmen^AUR

• KWin — The standard KDE window manager since KDE 4.0, ships with the first version of built-in support for compositing, making it also a compositing manager. This allows KWin to provide advanced graphical effects, similar to Compiz, while also providing all the features from previous KDE releases (such as very good integration with the rest of KDE, advanced configurability, focus stealing prevention, a well-tested window manager, robust handling of misbehaving applications/toolkits, etc.). Also serves as a compositor for Wayland.

https://techbase.kde.org/Projects/KWin || kwin

• lwm — Window manager for X that tries to keep out of your face. There are no icons, no button bars, no icon docks, no root menus, no nothing: if you want all that, then other programs can provide it. There is no configurability either: if you want that, you want a different window manager; one that helps your operating system in its evil conquest of your disc space and its annexation of your physical memory.

http://www.jfc.org.uk/software/lwm.html || lwm

• Marco — The MATE window manager, fork of Metacity.

https://github.com/mate-desktop/marco || marco

• Metacity — This window manager strives to be quiet, small, stable, get on with its job, and stay out of your attention. It is used by the legacy GNOME 2 and GNOME flashback sessions, and superseded by Mutter.

https://blogs.gnome.org/metacity/ || metacity

• Muffin — Window and compositing manager for Cinnamon, fork of Mutter, based on Clutter, uses OpenGL. It cannot be used outside of Cinnamon.

https://github.com/linuxmint/muffin/ || muffin

• Mutter — Window and compositing manager for GNOME, based on Clutter, uses OpenGL. Also serves a Wayland compositor.

https://gitlab.gnome.org/GNOME/mutter/ || mutter

• MWM — The Motif Window Manager (MWM) is an X window manager based on the Motif toolkit.

https://sourceforge.net/projects/motif/ || openmotif

• Openbox — Highly configurable, next generation window manager with extensive standards support. The *box visual style is well known for its minimalistic appearance. Openbox uses the *box visual style, while providing a greater number of options for theme developers than previous *box implementations. The theme documentation describes the full range of options found in Openbox themes.

http://openbox.org/ || openbox

• pawm — Window manager for the X Window system. So it is not a 'desktop' and does not offer you a huge pile of useless options, just the facilities needed to run your X applications and at the same time having a friendly and easy to use interface.

http://www.pleyades.net/pawm/^{[dead link 2021-05-17 ⓘ]} || pawm^AUR

• PekWM — Window manager that once upon a time was based on the aewm++ window manager, but it has evolved enough that it no longer resembles aewm++ at all. It has a much expanded feature-set, including window grouping (similar to Ion, PWM, or Fluxbox), auto-properties, Xinerama, keygrabber that supports keychains, and much more.

https://www.pekwm.org/ || pekwm

• Sawfish — 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 window manager functions are implemented in Lisp for future extensibility or redefinition.

https://sawfish.wikia.com/wiki/Main_Page || sawfish^AUR

• sowm — Simple Opinionated Window Manager that provides fullscreen toggleing, window centering and a mixed workflow (i.e. mouse and keyboard).

https://github.com/dylanaraps/sowm || sowm^AUR

• TinyWM — Tiny window manager created as an exercise in minimalism. It may be helpful in learning some of the very basics of creating a window manager. It is comprised of approximately 50 lines of C. There is also a Python version using python-xlib.

http://incise.org/tinywm.html || tinywm^AUR

• twm — Window manager for the X Window System. It provides titlebars, shaped windows, several forms of icon management, user-defined macro functions, click-to-type and pointer-driven keyboard focus, and user-specified key and pointer button bindings.

https://cgit.freedesktop.org/xorg/app/twm/ || xorg-twm

• ukwm — A lightweight GTK+ window manager, default window manager for UKUI desktop environment.

https://github.com/ukui/ukwm/ || ukwm

• UWM — The ultimate window manager for UDE.

http://udeproject.sourceforge.net/ || ude^AUR

• Wind — Small floating window manager. Tries to comply with ICCCM, EHWM, NetWM.

http://windwm.sourceforge.net/ || windwm^AUR

• WindowLab — Small and simple window manager of novel design. It has a click-to-focus but not raise-on-focus policy, a window resizing mechanism that allows one or many edges of a window to be changed in one action, and an innovative menubar that shares the same part of the screen as the taskbar. Window titlebars are prevented from going off the edge of the screen by constraining the mouse pointer, and when appropriate the pointer is also constrained to the taskbar/menubar in order to make target menu items easier to hit.

https://github.com/nickgravgaard/windowlab || windowlab^AUR

• Window Maker — X11 window manager originally designed to provide integration support for the GNUstep Desktop Environment. In every way possible, it reproduces the elegant look and feel of the NEXTSTEP user interface. It is fast, feature rich, easy to configure, and easy to use. It is also free software, with contributions being made by programmers from around the world.

https://windowmaker.org/ || windowmaker^AUR

• WM2 — Window manager for X. It provides an unusual style of window decoration and as little functionality as its author feels comfortable with in a window manager. wm2 is not configurable, except by editing the source and recompiling the code, and is really intended for people who do not particularly want their window manager to be too friendly.

https://www.all-day-breakfast.com/wm2/ || wm2^AUR

• worm — This is a floating, tag-based window manager for X11. It is written in the Rust programming language, using the X11RB library.

https://github.com/codic12/worm || worm-git^AUR

• Xfwm — The Xfce window manager manages the placement of application windows on the screen, provides beautiful window decorations, manages workspaces or virtual desktops and natively supports multiscreen mode. It provides its own compositing manager (from the X.Org Composite extension) for true transparency and shadows. The Xfce window manager also includes a keyboard shortcuts editor for user specific commands and basic windows manipulations and provides a preferences dialog for advanced tweaks.

https://docs.xfce.org/xfce/xfwm4/start || xfwm4

Tiling window managers

• Bspwm — bspwm is a tiling window manager that represents windows as the leaves of a full binary tree. It has support for EWMH and multiple monitors, and is configured and controlled through messages.

https://github.com/baskerville/bspwm || bspwm

• EXWM — EXWM (Emacs X Window Manager) is a full-featured tiling X window manager for Emacs built on top of XELB. It features fully keyboard-driven operations, hybrid layout modes (tiling & stacking), dynamic workspace support, ICCCM/EWMH compliance, RandR (multi-monitor) support, and a built-in system tray.

https://github.com/ch11ng/exwm || emacs-exwm-git^AUR

• Herbstluftwm — Manual tiling window manager for X11 using Xlib and Glib. 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 its 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).

https://herbstluftwm.org || herbstluftwm

• i3 — Tiling window manager, completely written from scratch. i3 was created because wmii, the developers' favorite window manager at the time, did not provide some features we wanted (multi-monitor done right, for example), had some bugs, did not progress for quite some time, and was not easy to hack at all (source code comments/documentation completely lacking). Notable differences are in the areas of multi-monitor support and the tree metaphor. For speed the Plan 9 interface of wmii is not implemented.

https://i3wm.org/ || i3-wm

• Larswm — A tiling window manager based on 9wm.

http://porneia.free.fr/larswm/larswm.html || larswm^AUR

• LeftWM — A tiling window manager written in Rust.

https://leftwm.org || leftwm^AUR

• Notion — Tiling, tabbed window manager for the X window system that utilizes 'tiles' and 'tabbed' windows.
  • Tiling: you divide the screen into non-overlapping 'tiles'. Every window occupies one tile, and is maximized to it
  • Tabbing: a tile may contain multiple windows - they will be 'tabbed'.
  • Static: most tiled window managers are 'dynamic', meaning they automatically resize and move around tiles as windows appear and disappear. Notion, by contrast, does not automatically change the tiling.

Notion is a fork of Ion3.

http://notion.sf.net/ || notion

• Ratpoison — Simple Window Manager with no fat library dependencies, no fancy graphics, no window decorations, and no rodent dependence. It is largely modeled after GNU Screen which has done wonders in the virtual terminal market. Ratpoison is configured with a simple text file. The information bar in Ratpoison is somewhat different, as it shows only when needed. It serves as both an application launcher as well as a notification bar. Ratpoison does not include a system tray.

https://www.nongnu.org/ratpoison/ || ratpoison

• Stumpwm — Tiling, keyboard driven X11 Window Manager written entirely in Common Lisp. Stumpwm attempts to be customizable yet visually minimal. It does have various hooks to attach your personal customizations, and variables to tweak, and can be reconfigured and reloaded while running. There are no window decorations, no icons, no buttons, and no system tray. Its information bar can be set to show constantly or only when needed.

Window Manager 1 0 5 9

https://stumpwm.github.io/ || stumpwm^AUR

• subtle — Manual tiling window manager with a rather uncommon approach of tiling: Per default there is no typical layout enforcement, windows are placed on a position (gravity) in a custom grid. The user can change the gravity of each window either directly per grabs or with rules defined by tags in the config. It has workspace tags and automatic client tagging, mouse and keyboard control as well as an extendable statusbar.

http://subforge.org/projects/subtle || subtle-hg^AUR

• WMFS2 — Window Manager From Scratch is a lightweight and highly configurable tiling window manager for X.

https://github.com/xorg62/wmfs || wmfs2-git^AUR

Dynamic window managers

• awesome — Highly configurable, next generation framework window manager for X. It is very fast, extensible and licensed under the GNU GPLv2 license. Configured in Lua, it has a system tray, information bar, and launcher built in. There are extensions available to it written in Lua. Awesome uses XCB as opposed to Xlib, which may result in a speed increase. Awesome has other features as well, such as an early replacement for notification-daemon, a right-click menu similar to that of the *box window managers, and many other things.

https://awesomewm.org/ || awesome

• dwm — Dynamic window manager for X. It manages windows in tiled, monocle and floating layouts. All of the layouts can be applied dynamically, optimising the environment for the application in use and the task performed. does not include a tray app or automatic launcher, although dmenu integrates well with it, as they are from the same author. It has no text configuration file. Configuration is done entirely by modifying the C source code, and it must be recompiled and restarted each time it is changed.

https://dwm.suckless.org/ || dwm^AUR

• echinus — Simple and lightweight tiling and floating window manager for X11. Started as a dwm fork with easier configuration, echinus became full-featured re-parenting window manager with EWMH support. It has an EWMH-compatible panel/taskbar, called ourico^AUR.

http://plhk.ru || echinus^AUR

• FrankenWM — Basically monsterwm with floating done right. Features that are added on top of basic mwm include: more layouts (fibonacci, equal stack, dual stack), gaps (and borders) are adjustable on the fly, minimize/maximize single windows, hide/show all windows, resizing master and stack individually, invert stack.

https://github.com/sulami/FrankenWM || frankenwm^AUR

• spectrwm — Small dynamic tiling window manager for X11, largely inspired by xmonad and dwm. 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 is configured with a text file. It was written by hackers for hackers and it strives to be small, compact and fast. It has a built-in status bar fed from a user-defined script.

https://github.com/conformal/spectrwm/ || spectrwm

• Qtile — Full-featured, hackable tiling window manager written in Python. Qtile is simple, small, and extensible. It is easy to write your own layouts, widgets, and built-in commands.It is written and configured entirely in Python, which means you can leverage the full power and flexibility of the language to make it fit your needs.

1 0 Math

https://github.com/qtile/qtile || qtile

• xmonad — 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. XMonad is configured in Haskell. For all configuration changes, xmonad must be recompiled, so the Haskell compiler (over 100MB) must be installed. A large library called xmonad-contrib provides many additional features

https://xmonad.org/ || xmonad

See also