Gestor de ventanas de mosaico (tiling window manager) escrito y configurable con Python.

• Web oficial
• Repositorio de código
• Registro de cambios

Para que Qtile pueda enviar notificaciones hay que instalar el módulo de Python dbus-fast (python-dbus-fast en Arch Linux)

Configuración por defecto. La tecla mod se refiere a la tecla super, la que suele tener la serigrafía del logo de Windows. Por defecto:

Para personalizar los atajos de teclado, en el fichero config.py, los configuramos en el array keys[]:

keys = [
    Key(["control", "mod1"], "t", lazy.spawn(terminal), desc="Lanzar terminal"),
]

El nombre de cada tecla está definido en el código fuente.

Para ejecutarlo con el servidor X, podemos añadir al fichero .xinitrc:

exec qtile start

Y podríamos lanzarlo entonces con startx

Para personalizar Qtile, se utilizará un fichero llamado config.py que situaremos en ~/.config/qtile/.

La configuración se hace en Python. Tras hacer cambios, antes de reiniciar Qtile, podemos probar si el fichero de configuración da algún error:

python -m py_compile ~/.config/qtile/config.py

Si no devuelve nada es que no ha habido ningún error y podremos reiniciar Qtile.

De todos modos, la recomendación es lanzar Qtile en un nueva sesión de X mediante Xephyr:

Xephyr -br -ac -noreset -screen 800x600 :1 &

Y lanzamos Qtile en esa sesión:

DISPLAY=:1 qtile &

En Qtile recomiendan usar este script que usa Xephyr

qtile cmd-obj -o cmd -f reload_config

qtile cmd-obj -o cmd -f restart

Personalizar atajos de teclado:

keys = [
    # Cerrar ventana con foco
    # Win + w
    Key(["control"], "w", lazy.window.kill(), desc="Cerrar ventana con foco"),
 
    # Mueve el foco de la ventana al siguiente panel
    # Alt + Tab 
    Key([mod1], "Tab", lazy.layout.next(),
        desc="Alternar foco"),
 
    # Alternar layouts
    # Win + Tab 
    Key([mod], "Tab", lazy.next_layout(), desc="Alternar layout"),
 
    # Lanzar un terminal
    # Ctrl + Alt + T 
    Key(["control", mod1], "t", lazy.spawn("urxvt"),
 
    # Moverse entre grupos
    Key(["control", mod1], "Right", lazy.screen.next_group(), 
        desc="Siguiente grupo"),
    Key(["control", mod1], "Left", lazy.screen.prev_group(), 
        desc="Anterior grupo"),
 
    # Captura de pantalla
    Key(
        [], "Print",
        lazy.spawn("scrot 'captura-%Y-%m-%d_$wx$h.png' -e 'mv $f ~/img/screenshots'"),
        desc="Captura de pantalla"
    ),
 
    # Captura de pantalla con selección
    Key(
        ["shift"], "Print",
        lazy.spawn("scrot -s 'captura-%Y-%m-%d_$wx$h.png' -e 'mv $f ~/img/screenshots'"),
        desc="Captura de pantalla"
    )
]

Si queremos que se inicien algunas aplicaciones cuando lo haga Qtile, podemos crear un script en bash llamado, por ejemplo, autostart.sh:

#!/bin/bash
 
# Fondo de pantalla
feh --bg-fill /home/pepito/wallpapers/img.png &
 
# Deshabilitar pitido
xset b off &
 
# Deshabilitar suspensión o pantalla en negro
xset -dpms; xset s off &

Le damos permisos de ejecución:

chmod +x ~/.config/qtile/autostart.sh

En el fichero de configuración de Qtile añadimos:

import os 
import subprocess
 
from libqtile import hook
 
def autostart():
    home = os.path.expanduser('~')
    subprocess.Popen([home + '/.config/qtile/autostart.sh'])

La ventana es cada elemento que contiene una aplicación.

floating_layout = layout.Floating(float_rules=[
    # Run the utility of `xprop` to see the wm class and name of an X client.
    Match(wm_class='confirm'),
    Match(wm_class='dialog'),
    Match(wm_class='download'),
    Match(wm_class='error'),
    Match(wm_class='file_progress'),
    Match(wm_class='notification'),
    Match(wm_class='splash'),
    Match(wm_class='toolbar'),
    Match(wm_class='confirmreset'),  # gitk
    Match(wm_class='makebranch'),  # gitk
    Match(wm_class='maketag'),  # gitk
    Match(wm_class='ssh-askpass'),  # ssh-askpass
    Match(title='branchdialog'),  # gitk
    Match(title='pinentry'),  # GPG key password entry
])

Un grupo es un contenedor de ventanas, como si fueran espacios de trabajo/escritorios virtuales.

Aparecen en la barra inferior. Por defecto son a, s, d, f, u, i, o y p.

Para modificarlas:

# Número de grupos y lista de parámetros
group_info = [
    ['1', 'www'],
    ['2', 'music'],
    ['3', 'docs'],
    ['4', 'video'],
    ['5', 'code']
]
 
# Instancia de los grupos
groups = [Group(name=i[0], label=i[1]) for i in group_info]
 
# Atajos de teclado por defecto para los grupos
for i in groups:
    keys.extend([
        # mod1 + letter of group = switch to group
        Key([mod], i.name, lazy.group[i.name].toscreen()),
 
        # mod1 + shift + letter of group = switch to & move focused window to group
        Key([mod, "shift"], i.name, lazy.window.togroup(i.name, switch_group=True)),
    ])

De esa manera, tras reiniciar Qtile, los grupos/espacios de trabajo se llamarán www, music, docs, video y code. Podremos acceder a cada uno de ellos mediante Mod + 1, para www; Mod + 2 para music, y así sucesivamente.

Los widgets son pequeños dibujos que se muestran en la barra de usuario. Un widget puede mostrar texto, imágenes y dibujos. Además, un widget puede ser configurado para actualizarse por tiempo, eventos de dbus, hooks, etc. y puede responder a eventos del ratón.

• Built-in widgets

Una disposición (layout) es un algoritmo para colocar las ventanas en un grupo. Como Qtile es un gestor de ventanas de mosaico, intenta usar el espacio de la forma más eficiente posible.

Por defecto, Qtile viene con las siguientes disposiciones:

• Floating: Qtile no gestiona el espacio, cada ventana abierta puede ponerse donde se quiera con el ratón (mod + botón izquierdo del ratón para mover la ventana).
• Bsp: inspirado en bspwm
• Columns: extensión de la disposición stack
• Matrix: divide la pantalla en una matriz con celdas del mismo tamaño.
• Max: cada ventana ocupa toda la pantalla.
• MonadTall: emula el comportamiento por defecto del gestor XMonad.
• MonadThreeCol: emula el comportamiento de la disposición ThreeColumns de XMonad.
• MonadWide: emula el modo horizontal del gestor XMonad.
• RatioTile:
• Slice:
• Spiral: divide la pantalla en ventanas en forma de espiral.
• Stack:
• Tile: divide la pantalla en dos, una maestra que no se divide y otra que puede ir añadiendo paneles.
• TreeTab: se comporta como Max, pero muestra unas pestañas en un panel lateral con las ventanas abiertas.
• VerticalTile:
• Zoomy:

Para tener la posibilidad de alternar entre layouts, los añadimos en el fichero de configuración:

layouts = [
    layout.Bsp(),
    layout.Matrix(),
    layout.Columns(),
    layout.Max(),
    layout.Floating(),
    layout.MonadTall(
        border_focus="#bd93f9"
    ),
    layout.MonadWide(),
    layout.RatioTile(),
    layout.Slice(),
    layout.Stack(),
    layout.Tile(),
    layout.TreeTab()
    layout.VerticalTile(),
    layout.Zoomy(),
]

Para cambiar al vuelo de disposición, la combinación de teclas es mod + Tab.

• Documentación sobre los layouts

ScratchPad es un tipo especial (y por defecto invisible) de grupo que actúa como contenedor para configuraciones DropDown.

Útil para saber si hay algún error con la configuración de Qtile, por ejemplo, el registro se lleva en ~/.local/share/qtile/qtile.log

• Documentación oficial
• Qtile (Wiki ArchLinux)