- LUV: Window Managers
- 30 Window Managers in 30 days 
- Box-Look.org - Stuff for your Windowmanager
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.
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.
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.
- YouTube: OpenWindows / OPEN LOOK / olwm
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.
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.
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.)
tvtwm fork, Has pie menus (circle around the mouse).
Motif Window Manager
Derived from twm, has lots of forks: Afterstep, Xfce, Enlightenment, WindowMaker, Metisse, Bowman, AmiWM, FVWM-XPM (pre-Enlightenment), NWM, MVLWM, SCWM
- https://en.wikipedia.org/wiki/FVWM95 - based on the popular FVWM 2 window manager. It is similar to the original FVWM, but is designed to closely resemble the look of Windows 95.
- https://github.com/fvwmorg/fvwm3 - the successor to fvwm2
- http://www.lysator.liu.se/~marcus/amiwm.html - FVWM descendant
wm2 / wmx
1996 / 1998
- Workspace - a fork of Window Maker.
- http://www.icewm.org 
- https://en.wikipedia.org/wiki/Macintosh-Like_Virtual_Window_Manager - FVWM descendant
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.
derived from mwm. uses the Motif widget toolkit, normally used on Silicon Graphics workstations running IRIX.
- http://www.afterstep.org/ - FVWM descendant
- http://scwm.sourceforge.net/ - FVWM descendant
Succeeded by Ion
Successor to PWM, development dead
- 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
Fork of aewm. Stacking.
- https://en.wikipedia.org/wiki/Metacity - gnome 2
Calm Window Manager, stacking. was based on evilwm, rewritten as a 9wn fork, then rewritten
Tiling/stacking, plan9 like interface.
Stacking, Windows 98 like.
Tiling, configuration in source header file.
- https://sourceforge.net/projects/adwm/ - old fork
- 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.
Stacking, based on the FLTK toolkit
- Matchbox - an Open Source base environment for the X Window System running on non-desktop embedded platforms such as handhelds, set-top boxes, kiosks and anything else for which screen space, input mechanisms or system resources are limited.Matchbox consists of a number of interchangeable and optional applications that can be tailored to a specific non desktop platform to enhance usability in a ‘constrained’ environment.
- 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.
- http://www.youtube.com/watch?v=AyNkBLhIpQk&hd=1 - example vid
- template config
cabal --recompile after changing ~/.xmonad/xmonad.hs
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 - a highly configurable, next generation framework window manager for X. It is very fast, extensible and licensed under the GNU GPLv2 license.It is primarily targeted at power users, developers and any people dealing with every day computing tasks and who want to have fine-grained control on their graphical environment.
- https://github.com/atsepkov/awesome-awesome-wm - A curated list of awesome tools/scripts/configs for Awesome Window Manager.
To debug rc.lua changes:
Xephyr :1 -ac -br -noreset -screen 1152x720 & DISPLAY=:1.0 awesome -c ~/.config/awesome/rc.lua.new
- https://github.com/lcpz/lain - Layouts, widgets and utilities for Awesome WM 4.x
- https://github.com/montagdude/awesome-appmenu - a tool to create a menu of installed applications for the awesome window manager. It searches for and parses .desktop files to find the name, execution command, and icon of installed applications. These are then grouped into categories, sorted, and written to a lua script ($HOME/.config/awesome/appmenu.lua) that can be used in your awesome WM configuration script.
- https://github.com/blueyed/awesome-cyclefocus - Alt-Tab for the awesome window manager (and more)
- https://github.com/mut-ex/awesome-wm-nice - An Awesome WM module that add MacOS-like window decorations, with seamless titlebars, double click to maximize, and window shade feature
- https://github.com/intrntbrn/smart_borders - full titlebar functionality without sacrificing space
- https://gist.github.com/intrntbrn/08af1058d887f4d10a464c6f272ceafa --- awesomewm fancy_taglist: a taglist that contains a tasklist for each tag.
- https://github.com/intrntbrn/icon_customizer - awesomewm icon_customizer: set custom icons for gui and terminal applications
- https://github.com/Nooo37/bling - Utilities for the awesome window manager
- https://github.com/seberm/awesome-vim-bindings - Awesome window manager with Vim-like control
- https://github.com/intrntbrn/awesomewm-vim-tmux-navigator - lets you navigate seamlessly between system windows, vim splits and tmux panes using a consisent set of hotkeys. It's based on christoomey/vim-tmux-navigator and fogine/vim-i3wm-tmux-navigator
- https://github.com/uzsolt/keychains - A simple keychain module which allows to use keychains in awesome window manager.
- https://github.com/jcrd/awesome-ez -a library for Awesome window manager that aims to simplify the creation of key and button bindings. It is based on code from the old Awesome wiki.
- https://github.com/crater2150/awesome-modalbind - Modal keybindings for AwesomeWM
- https://github.com/potamides/modalawesome - Framework for modal, vi-like keybindings for the awesome window manager
- https://gist.github.com/mikaelz/b85c8d97fcee55c33b88 - Awesome WM config for multimedia keys to control Spotify
- https://github.com/bioe007/awesome-shifty - an Awesome 3 extension that implements dynamic tagging.
- https://github.com/Elv13/tyrannical - Dynamic tagging configuration system for awesomeWM
- https://github.com/Drauthius/awesome-sharedtags - A simple implementation for creating tags shared on multiple screens for awesome window manager.
- https://github.com/Veratil/awesome-retain - Awesome Lua module for retaining tags and their layouts between restarts and screen adds/removes
- https://github.com/AfoHT/taggrid - AwesomeWM extension providing a tag grid
- https://github.com/jcrd/awesome-viewport -a library for Awesome window manager that manages tags based on viewports.
- https://elv13.github.io/client_tiling/dynamite.html -A drop-in replacment for the stateless layout suitsThis system also add the possibility to write handlers enabling the use of tabs, spliters or custom client decorator.
- https://github.com/ciiqr/thrizen - three column layout for awesome wm
- https://github.com/JamesWilmot/AwesomeWMColumnsLayout - columns layout with arbitrary number of columns.
- https://github.com/michaelbeaumont/awesome-leaved - based on i3 and arranging clients into containers
- https://github.com/ItsJimi/awesome-treetile -binary tree-based tiling layout, can split focused window either vertically or horizontally, like bspwm. Working fork of Treesome.
- https://github.com/drewby/basl - Big Ass Screen Layout for AwesomeWM
- https://github.com/groboclown/awesomewm-petronia - Custom Layout and Keybindings to make Petronia style interactions in Awesome WM
- https://github.com/xinhaoyuan/layout-machi -A manual layout for Awesome with a rapid interactive editor.
- https://github.com/sebth/awesome-overlap -arrangeswindows similar to the `tile' layout, the difference being that windowsresiding in the same column are overlapped instead of stacked.
- https://github.com/jcrd/awesome-dovetail - a layout for Awesome featuring two visible tiled clients. It is similar to the deck layout in other dynamic window managers.
- https://github.com/notnew/awesome-frames - Divides the workarea into 3 frames, which are like emacs windows. Each frame may be associated with a client window to show in the frame. Functions are provided to switch between frames and to pull windows unassociated windows into the current frame.This is similar (though less flexible than) the layout used by stumpwm or emacs' windows and buffers.
- comp.window-managers.awesome: Re: Multiple row wibox
- https://github.com/cool-cool-sweat/fenetre - awesome 4 wibar global titlebar with client title + controls/property indicators
- https://github.com/hoelzro/obvious - Widget library for the awesome window manager. This is a fork of the original obvious repo
- Widgets for Awesome WM - Set of super simple widgets compatible with Awesome Window Manager v.4+.
- https://github.com/deficient/keyboard-layout-indicator - Keyboard layout indicator/switcher widget for awesome-wm
- https://github.com/deficient/quicklaunch -Simple quicklaunchbar widget.
- https://github.com/deficient/calendar - Calendar popup for awesome WM
- https://github.com/daskol/awesome-pulseaudio-widget - Awesome WM text widget to display volume which leverages D-Bus PulseAudio interface.
- https://github.com/vladimir-g/fainty - Small widget library for Awesome WM
- https://github.com/pltanton/net_widgets -If you use netctl or another network manager which doesn't provide any good tray icon or if you want something more native than nm-applet, this is for you.
- https://github.com/streetturtle/awesome-buttons - Button widget library for Awesome Window Manager
- https://github.com/sgnix/awesome-dmenu -native dmenu widget
- https://github.com/macunha1/awesomewm-media-player-widget - AwesomeWM generic Media Player Widget implementation in pure Lua through MPRIS D-Bus interface spec
- https://github.com/AlterationBrick/awesome-playerctl-widget - Music player widget for the Awesome window manager using playerctl
- https://github.com/zackpete/hints - Window picker with hints for Awesome
- http://awesome.naquadah.org/wiki/Revelation - Expose-like client selection.
- https://github.com/Elv13/radical - large Awesome extension module, provides a unified interface to generate multiple types of menus.
You can use Pango markup in a text string. This allows formatting 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: ….
- https://github.com/jechasteen/gratuitous - an IDE for awesome window manager configs and themes. The name is a play on the adjective names of the awesome libs (awful, beautiful, vicious)
- https://github.com/Elv13/repetitive - Focus tag, Focus client and restore cursor position, Record/Play mouse+keyboards macros
- Adding an Alacritty based drop-down terminal in AwesomeWM
- https://github.com/Elv13/radical - unified interface to generate multiple types of menus.
- https://github.com/Elv13/drawer - A bunch of pull-down panel for AwesomeWM
- :carrot: - Carrot awesomeWM personalization application
- https://github.com/Elv13/collision - A window management module for AwesomeWM
- https://github.com/berlam/awesome-remember-geometry - Remember client location when switching between floating, tiling and maximized
- https://github.com/berlam/awesome-fullscreen -toggles ontop elements when another component goes fullscreen. While a component is in fullscreen the energy savers are turned off (e.g. disabled blank screen).
- https://github.com/worron/redflat - Extension module for Awesome WM
- https://github.com/berlam/awesome-switcher - Switch clients in Awesome WM with the familiar preview functionality
- https://github.com/grandchild/autohidewibox -Auto-hide the awesome-wibox/taskbarIf you ever wanted to squeeze out that last bit of screen real estate in awesome and only show the wibox when needed (i.e when pressing the ModKey), this is for you.Since awesome doesn't allow easy access to the states of the Super/Mod-Key itself in rc.lua, one cannot simply show the wibox while the ModKey is pressed and hide it again on release. This little python daemon will sit in the background and do just that.
- https://github.com/notnew/awesome-scratch -used to show and hide scratch windows. It takes a shell command to launch the scratch window and a rule to match the scratch window.
- https://github.com/vladimir-g/awpwkb -a simple per-window keyboard layout switcher for Awesome WM.It uses awesome XKB functions, so awesome 4 is required. Layouts stored in X property awpwkb_layout and they are persistent between awesome restarts.
- https://github.com/mut-ex/awesome-wm-slidebar - an easy to use, configurable, multi-purpose, animated widget bar written in Lua for Awesome WM
- https://github.com/jcrd/awesome-launch - a library for Awesome window manager that provides functions to spawn clients with single instance IDs using wm-launch.
Themes and configs
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.
If xdg/awesome default config loads instead of .config/awesome, this is due to error in the rc.lua.
- 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.
- 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
Based on wmii, tiling/floating.
- https://github.com/Airblader/i3 - i3-gaps
- YouTube: i3wm: Jump Start (1/3) - configuration guides
- YouTube: i3 screencast: containers and the tree data structure
- YouTube: i3 Window Manager Overview
- YouTube: i3 - An Improved Tiling Window Manager
i3-msg exec application # start your application on the workspace where it was called
- https://github.com/greshake/i3status-rust - a feature-rich and resource-friendly replacement for i3status, written in pure Rust. It provides a way to display "blocks" of system information (time, battery status, volume, etc) on the i3 bar. It is also compatible with sway.
- https://github.com/RasmusLindroth/i3keys - lists all the keys that are bound to some action in i3 or sway, and all keys that are not bound to any actions.
- How do I find the criteria for use with i3 config commands like for_window (e.g. to force splashscreens and dialogs to show in floating mode)?
- https://github.com/kenyonj/i3-create-config - created in an effort to allow the better organization of an i3 config file. Currently there is no way to include extra files in the main ~/.i3/config file.
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/cameronleger/i3-workspacer - simplifying large amounts of i3 workspaces with naming and infinite* workspace traversal
- https://github.com/Chimrod/i3_workspaces - allow you to configure your workspace easily. I use it for setting a wallpaper to each workspace, or launch application on some workspaces.
- https://web.archive.org/web/20160420173541/http://www.kelvinblog.tk/i3wm-restore-layout - "i3 can only swallow new windows, but not existing ones. ... I use xdotool to unmap all visible windows and map them again (Mapping a window means to let the WM manage it). This is the script I use"
- 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.
- https://github.com/JonnyHaystack/i3-resurrect - Simple solution to saving and restoring i3 workspaces
- https://github.com/jamesofarrell/i3-swallow - used to swallow (send to the scratchpad) a terminal window after a blocking application is run in i3.
..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
- https://github.com/olemartinorg/i3-alternating-layout - Scripts to open new windows in i3wm using alternating layouts (splith/splitv) for each new window
- tinywm - a tiny window manager that I created as an exercise in minimalism. It is also maybe helpful in learning some of the very basics of creating a window manager. It is only around 50 lines of C. There is also a Python version using python-xlib. It lets you do four basic things: Move windows interactively with Alt+Button1 drag (left mouse button), Resize windows interactively with Alt+Button3 drag (right mouse button), Raise windows with Alt+F1 (not high on usability I know, but I needed a keybinding in there somewhere), Focus windows with the mouse pointer (X does this on its own) 
Fork of Ion
- 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
- http://hack.org/mc/hacks/mcwm - minimalist, floating window manager written using XCB, the X protocol C binding.The only window decoration is a thin border. All functions can be done with the keyboard, but moving, resizing, raising and lowering can also be done with the mouse.If you don't like the default key bindings, border width, et cetera, look in the config.h file, change and recompile.
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.
Fork of metacity, used by MATE.
Tiling, fork of i3 with touchscreen features.
- 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)
- YouTube: 28c3 LT Day 4: herbstluftwm
- 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.
- nwm - A dynamic window manager for X11 written with Node.js
- http://merproject.org/ - Mer is an open, mobile-optimised, core distribution aimed at device manufacturers; powered by Qt/QML and HTML5 - openly developed, inclusive, and meritocratically governed. MeeGo based.
dminiwm / snapwm
Minimal and lightweight dynamic tiling window manager. Fork of catwm.
- https://github.com/moetunes/Nextwm - snapwm
Floating and tiling, per monitor desktops. Written in Go.
TTWM / 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 is a full-featured, hackable tiling window manager written in Python.
- http://aerosuidae.net/goomwwm/ Goomwwm: Get out of my way, Window Manager!
- https://github.com/baskerville/bspwm bspwm is a tiling window manager where each window is represented as the leaf of a binary tree. It is controlled and configured via bspc. bspwm have only two sources of informations: the X events it receives and the messages it reads on a dedicated socket. Its configuration file is $XDG_CONFIG_HOME/bspwm/autostart. Keyboard and pointer bindings are defined through sxhkd. Example configuration files can be found in the examples directory.
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
- https://github.com/Chrysostomus/bspwm-scripts - Various scripts for controlling bspwm. Copied and edited from various repos from github.
- YouTube: Full Demo: BSPWM on Debian 10 'Buster' - and playlist
- https://github.com/ntrrgc/right-window - Utility to move the focus between windows following cardinal directions
- https://gitlab.com/jallbrit/desknamer - automatically rename bspwm desktops based on the applications inside
- bspwm external rules test ($1695296) · Snippets · GitLab
Deep Space Window Manager
- 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
- https://github.com/venam/2bwm - A fast floating WM written over the XCB library and derived from mcwm.
- https://github.com/michaelforney/swc - a small Wayland compositor implemented as a library.It has been designed primary with tiling window managers in mind. Additionally, notable features include:Easy to follow code baseXWayland supportCan place borders around windows
- https://github.com/michaelforney/velox - a simple window manager based on swc. It is inspired by dwm and xmonad. velox uses tag-based window management similar to dwm. This allows you to construct your workspace by selecting a set of tags to work with. However, in contrast with dwm, windows do not have any screen associated with them; they are shown on whichever screen has their tag selected, allowing you to easily move windows between screens by selecting their tag on a different screen. This is similar to the multi-monitor workspace switching in xmonad.To ensure that we never attempt to show a window in two places at once, we have to impose several constraints. First, each window must have exactly one tag. In practice, I've found that I rarely intentionally mark a window with more than one tag anyway. Second, when you select a tag that is currently display on a different screen, the tag is first deselected from that screen.
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.
- https://github.com/HarveyHunt/howm 
written in rust
- 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.
See also the XDE apps.
- https://github.com/JeffHoogland/moksha - an advanced window manager for X11 based on Enlightenment DR17.
non-reparenting, tiling window manager with window decorations. It’s a learning project started in December 2015.
Lunchbox Window Manager
- https://github.com/alysander/lunchboxwm - A tiling window manager for X11
- https://github.com/groboclown/petronia - A Python Tiling Window Manager
- LeftWM - a tiling window manager written in rust for stability and performance. The core of left is designed to do one thing and one thing well. Be a window manager. Because you probably want more than just a black screen LeftWM is built around the concept of theming. With themes you can choose between different bar / compositor / background / colors, whatever makes you happy. LeftWM has been built from the very beginning to support multiple screens and has been built around ultrawide monitors. You will see this with the default key bindings.
- https://github.com/jaelpark/chamferwm - A tiling window manager with Vulkan based compositor.
- https://github.com/jcrd/dovetail -dovetail is an opinionated window manager based on awesome.
- Twindy - a window manager for linux (and possibly any system running an X server?) inspired byTracktion, the multitrack audio editor/sequencer for Windows and OS X. Twindy tries to apply Tracktion's workflow, where everything is on screen at once, to a window manager. As such, there are two panels, a main panel where new windows/programs open by default and may be selected using tabs, and a lower panel, which can only hold one window/program at a time.The idea is that you'll do your main work in the top panel, and use the bottom panel for a terminal, or a file manager you'd want to keep open.
- https://github.com/JLErvin/berry - A healthy, bite-sized window manager written over the XLib Library
- https://gitlab.com/ayekat/karuiwm - a lightweight, dynamically tiling window manager for X.It is based on dwm and inspired by xmonad.
- https://github.com/aesophor/Wmderland - X11 i3-like tiling window manager using space partitioning tree
- https://github.com/dylanaraps/sowm - An itsy bitsy floating window manager with roots in catwm.
- https://github.com/avahe-kellenberger/nimdow - written in Nim. NOTE: This is a WIP and currently only usable on single monitor setups. I am using this project to learn Nim, x11, and to replace my build of dwm (written in C).
- LeftWM - a tiling window manager written in rust for stability and performance. The core of left is designed to do one thing and one thing well. Be a window manager. Because you probably want more than just a black screen LeftWM is built around the concept of theming. With themes you can choose between different bar / compositor / background / colors, whatever makes you happy.LeftWM has been built from the very beginning to support multiple screens and has been built around ultrawide monitors. You will see this with the default key bindings.
- https://github.com/instantOS/instantWM - Window manager for instantOS
- https://github.com/dylanaraps/wm - status: messy and mostly working
- InfiniteGlass - This is a minimalistic compositing window manager for X with infinite desktop, infinite zoom and infinite virtual window pixel resolution.
- https://github.com/periish/tofu - a shell based window manager for x11fs. It uses x11fs to parse events and control windows. tofu is built to be easily extensible, and scriptable. It is a simple shell script itself. tofc is a program that can be used in tandem with tofu. It controls windows. tofu on it's own does not enforce any particular behaviour for windows, however some example workflows exist in the contrib directory. tofu does not handle keybinds - sxhkd or XBindkeys is reccomended.
See also Wayland
- https://github.com/jjttjj/wm - a clojure(script) library which provides an immutable datastructure that's useful for implementing a tiling window manager.
- https://github.com/sminez/penrose - A library for writing an X11 tiling window manager