sglavoie.com – Tag: i3

Managing multiple tmux sessions at once

Sébastien Lavoie — Sun, 19 Sep 2021 18:13:00 -0500

Introduction

Released back in 2007, tmux keeps being amazing! Because I have never bothered automating anything to make its use simpler, it took some time for it to become a working environment I enjoy for everyday use. This is a thing of the past: thanks to Oleksandr Kocherhin from Monsterlessons Academy, who shared his tmux workflow in his YouTube video titled Best Terminal Application for Web Development, I saw a few automation opportunities I thought were worth tackling.

In this post, I’m sharing a little tip about managing tmux sessions that was inspired from the mentioned video. I am using i3wm on Linux, but you can adapt this with any desktop environment as long as you can trigger the execution of programs with a keyboard shortcut in one way or another. I will be using Rofi and the find command, which you can find on Unix systems. If you would rather use dmenu instead of Rofi with this script, this article can serve as a reference. Enough said, let’s get to it.

What is this all about?

The idea is simple: have a few keyboard shortcuts to manage tmux sessions. That means being able to open new sessions and being able to kill them too. I kept this setup very simple on purpose but of course some improvements could be made. For instance, it could be nice to know which projects have already been opened so that the script doesn’t prompt you with a list of projects that include projects that you have already launched, but I haven’t found the need so far to deal with this potential issue as I tend to only work on a couple of projects during the course of a given day.

In summary, here is what we want to achieve in this post:

Configure projects so that when we want to open them, they will be set up in the right directory with servers running, etc.;
Open a tmux session with a keyboard shortcut, listing all projects that were configured in the previous step;
Kill any opened tmux session with another keyboard shortcut.

That’s it!

1. Configuring projects to launch tmux sessions

Firstly, we need to create new files to open our projects in the way we want. Basically, we need to create a file, let’s call it .tmux, and put it at the root of the project we’re interested in working with tmux. Then, we need to put some instructions that will be run with the shell (e.g. Bash or Zsh) so that tmux commands will be run automatically for us and let us “attach” to the session once all the necessary actions are performed. That means we need to make that file executable. In the terminal, this would be done as follows, assuming the project’s folder is the current working directory:

bash

chmod +x .tmux

At last, we want to give some orders to tmux so that when we execute that file, it will open our project in a pre-configured state so we’re ready to go. This will need to be customized depending on your needs, but here is a simple example to illustrate what could happen. So, we could put the following inside the .tmux file:

 bash
 
 
 
#!/bin/sh

set -e

if tmux has-session -t=my-project 2> /dev/null; then
 tmux attach -t my-project
 exit
fi

tmux new-session -d -s my-project -n nvim -x $(tput cols) -y $(tput lines)

# Neovim
tmux send-keys -t my-project:nvim "n" Enter

# Servers
tmux new-window -t my-project -n servers
tmux send-keys -t my-project:servers "cd frontend && yarn start" Enter

tmux split-window -t 2 -v -p 50 # split it into two halves
tmux send-keys -t my-project:servers "cd backend && ap && uvicorn main:app --reload" Enter

tmux attach -t my-project:nvim

Here is what is happening:

If our project, named my-project, has a tmux session already running, then we “attach” to it and nothing more is done.
Otherwise, the session is created in “detached” mode so we can run a few commands smoothly and later attach to the created session.
With the -n flag, we name the window to be created (here, the first window is nvim).
Then, we “send” keys to the session, to that newly created nvim window. In this case, we send a single keystroke n, which is just an alias for executing Neovim.
In a new window named servers, we send keys to execute the frontend server.
Then, we split the second window we just created vertically and we run the commands needed to launch the backend server, again making use of Bash aliases for convenience.
Finally, we attach to the session and we open the first window nvim, ready to work.

And just like this, what takes quite a few steps to do manually can be automated in one go when setting up the environment at the beginning of a working bout. Now, it could be convenient to create a generic template for the above script to use when creating new projects, especially if those tend to be short-lived and share some properties (e.g. maybe they all need to launch some kind of server in the background).

2. Script to open projects

Firstly, we need a way to list and open all “known” projects. This is achieved in this example very simply with the find command as well as with the help of rofi. The script in question is as follows:

 bash
 
 
 
#!/bin/bash

# Get the path to the `.tmux` file to execute using `find` and `rofi`
PROJECT=`find $HOME/dev -type d \( -name node_modules -o -name .venv \
 -o -path name \) -prune -false -o -name '.tmux' \
 | rofi -i -dmenu -theme purple -font 'JetBrainsMono 14' \
 -width 90 -show window`

# Get the full directory path to the `.tmux` file, excluding the filename
PROJECT_DIR=`echo $PROJECT | xargs -I {} dirname "{}"`

# If $PROJECT is empty (e.g. pressing Esc at the prompt), don't do anything
if [ ! -z "$PROJECT" ]; then
 kitty --directory "$PROJECT_DIR" -e "$PROJECT"
fi

So, what this does is this:

It finds all the directories where a .tmux file exists, excluding non-useful folders like node_modules. The -prune flag is passed to avoid recursion further inside a directory once a .tmux file is found. The results of find are “piped” into rofi, which displays the results. User selection is then stored in the PROJECT variable.
Once a file is selected, the full path without the filename is extracted and stored in the PROJECT_DIR variable.
Finally, all that is left to do is check if the user selected a project and if so, run it with the desired terminal from the correct directory. This will be different for most terminal emulators: here, an example is shown with the kitty terminal.

3. Script to close projects

Here, we are concerned with the sessions that are now opened and that we might want to close. In a similar fashion as what we did to open projects, we want to kill them with a script that will run Rofi and do the job silently in the background. One such script that will get us there is shown below:

 bash
 
 
 
#!/bin/bash

# Get the name of all running sessions
TMUX_SESSIONS=`tmux ls | cut -f1 -d ":"`

# No listed session, then notify about it
if [ -z "$TMUX_SESSIONS" ]; then
 notify-send "No active tmux session found"
 exit 0
fi

# Show all running sessions with Rofi and store the selection in a variable
SESSION=`echo $TMUX_SESSIONS | rofi -sep ' ' -i -dmenu -theme purple -font 'JetBrainsMono 14' \
 -width 90 -show window`

# Kill the selected session
tmux kill-session -t $SESSION

In this case, the usage is quite straightforward: only running sessions are shown, so it’s just a matter of choosing the one we want to kill or pressing the Escape key to abort the Rofi pop-up.

Example workflow

It’s a matter of setting up keyboard shortcuts to run the scripts to open and kill projects. For instance, one such configuration for the i3 window manager would be as follows:

 bash
 
bindsym $mod+Mod1+p $exec ~/path/to/projects-start.sh
bindsym $mod+Mod1+k $exec ~/path/to/projects-kill.sh

A simple shortcut lets us choose sessions to open.
Next, if we decide to kill a session at some point, we have another shortcut to do that.

Conclusion

Far from being a perfect solution (although it already feels comfortable as a main driver), this workflow initiates what I think can lead to substantial optimizations when it comes to using tmux. There’s room for improvement when a user selects an already opened session: ideally, we would just switch to that session automatically. These details need to be implemented based on the window manager that’s being used, but suffice to say, it can be done! In any case, I hope this may give you a semblance of inspiration to take this idea to the next level. There are tools to help with session persistence, such as tmux-resurrect, but that’s a topic for another time.

More resources and references

Best Terminal Application for Web Development, original inspiration for this workflow. — Monsterlessons Academy, YouTube.
The tmux wiki, GitHub.
tmux-resurrect, GitHub.

A Guided Tour of an i3 Configuration

Sébastien Lavoie — Sat, 15 Aug 2020 10:51:00 -0500

Introduction

In Using i3 as a Window Manager for Increased Productivity, a number of reasons were given to get going with this fantastic tiling window manager. Now, it’s time to jump in and explore how to actually use i3! If you’re looking for an in-depth guide, the official i3 documentation or the i3 page on the Arch Wiki are awesome resources to dive deeper. Here, we’ll focus on day-to-day usage based on my current configuration file which I have used and refined over the past three years or so. I hope that you’ll be able to glean useful tips and tricks to apply to your own use case.

The Configuration File

To set keybindings, it may be handy to know the keycodes and their respective names. To get a full list, you can use xmodmap -pk in the terminal. If you’re not sure of the name of the key you want to press (is it “PageDown”, “PageDwn” or “Next”?), you can retrieve it by executing the xev command, which will open two windows: one for capturing the actual key press and the other one to display the relevant details for that key. For example, if you press the backspace key, the output will contain something like keycode 22 (keysym 0xff08, BackSpace). From there, you will know that a mapping would be of the form mod+BackSpace, where mod is the modifier of your choice that is usually specified at the top of the configuration file. Now we can start!

i3 config shortcuts

 bash
 
 
 
# Paths and names
set $brightness-laptop-down "light -U 1"
set $brightness-laptop-up "light -A 1"
set $brightness-monitor-default "python3 ~/.local/bin/monitor_brightness default"
set $brightness-monitor-down "python3 ~/.local/bin/monitor_brightness down"
set $brightness-monitor-up "python3 ~/.local/bin/monitor_brightness up"
set $brightness-toggle-laptop ~/.local/bin/toggle_laptop_brightness
set $default-web-browser brave-browser-stable
set $launcher-python-term ~/.config/ipython_launch.sh
set $launcher-temp-notes ~/.config/tmpnotes_launch.sh
set $launcher-todoist ~/.config/todoist_launch.sh
set $path-xrandr-both ~/.config/i3/run_xrandr.sh
set $path-xrandr-laptop ~/.config/i3/run_xrandr_laptop.sh
set $path-xrandr-monitor ~/.config/i3/run_xrandr_monitor.sh
set $screenshots-folder ~/Pictures/screenshots/
set $todoist-app-name "crx_elldfnmogicegdcphgljaoaklkpcnbnn"
set $toggle-mic-on-off ~/.local/bin/toggle_mic_source

# i3 specific
set $center-mouse exec ~/.config/i3/center-mouse
set $default-web-browser-class "(?i)brave-browser"
set $exec exec --no-startup-id
set $output-primary output eDP
set $output-secondary output HDMI-A-0
set $python-term "ipythonterm"
set $scratchpad-size 1920 1060
set $temp-notes "tmpnotes"
set $volumepath ~/.config/i3-volume/volume

# set mod key (Mod1=Alt, Mod4=Super)
# ⇒ the main modifier used to trigger shortcuts
set $mod Mod4

# Workspaces
#######################################
# Workspace names — can be customized with emojis and names
# ⇒ I find I like minimalism best and just mentally associate
# one workspace number with a specific type of task
# ⇒ those are set across all monitors
set $ws1 "1"
set $ws2 "2"
set $ws3 "3"
set $ws4 "4"
set $ws5 "5"
set $ws6 "6"
set $ws7 "7"
set $ws8 "8"
set $ws9 "9"
set $ws10 "10"

# Modes
#######################################
# set shut down, restart and locking features
# ⇒ type `$mod+Shift+Delete` then either `e`, `r` or `s`
mode "$mode_system" {
 bindsym e exec --no-startup-id i3-msg exit
 bindsym r exec --no-startup-id systemctl reboot
 bindsym s exec --no-startup-id systemctl poweroff

 # exit system mode with "Enter" or "Escape"
 bindsym Return mode "default"
 bindsym Escape mode "default"
}
set $mode_system (e)xit, (r)eboot, (s)hutdown
bindsym $mod+Shift+Delete mode "$mode_system"

# resize with smaller steps to get more control
mode "resize" {
 bindsym h resize shrink width 2 px or 2 ppt
 bindsym j resize grow height 2 px or 2 ppt
 bindsym k resize shrink height 2 px or 2 ppt
 bindsym l resize grow width 2 px or 2 ppt

 # exit resize mode: Enter or Escape
 bindsym Return mode "default"
 bindsym Escape mode "default"
}
bindsym $mod+r mode "resize"

# Show the next scratchpad window or hide the focused scratchpad window.
# If there are multiple scratchpad windows, this command cycles through them.
# There is an additional keybinding to allow a floating window to be toggled
# (recovered as a normal window).
# keycode 179 = F10 button
# (not the actual F10 key, but same button on my laptop with default function!)
mode "Scratchpad"{
 bindcode 179 scratchpad show, resize set 1920 1060, move position center; \
 scratchpad show, resize set 1920 1060, move position center
 bindsym $mod+Shift+space floating toggle; mode "default"
 bindsym $mod+Escape kill; mode "default"
 bindsym Escape scratchpad show; mode "default"
}
bindcode 179 mode "Scratchpad"; scratchpad show, resize set 1920 1060, move position center

# Caps Lock indicator, seen at
# https://www.reddit.com/r/i3wm/comments/k8m4k4/share_your_i3_tips_and_tricks_that_you_have/gf2lppd
mode "-------------------- CAPSLOCK --------------------" {
 bindsym Caps_Lock mode "default"
}
bindsym Caps_Lock mode "-------------------- CAPSLOCK --------------------"

# Sound
#######################################
set $statuscmd i3status

# Signal used to update the status line
set $statussig SIGUSR1

# Amount to increase/decrease volume as a percentage
set $volumestep 5

# Font
#######################################
# font for window titles
# ⇒ this is what you see in your i3bar
set $font-small font xft:Lato 12
set $font-medium font xft:Lato 14

# Set default font
$font-small

# Font used with Rofi (dmenu alternative)
set $rofi-font 'JetBrainsMono 16'

# Keyboard
#######################################
# Set the compose key to right Control
set $compose-key "compose:rctrl"

A few notes on the i3 config shortcuts:

This section appears at the top because it will affect how i3 works in general.
It makes extensive use of the set command so that all important shortcuts and paths to programs that could “break” if they are missing are easy to configure globally.
It sets all the different modes that i3 can use so it can be extended in one single place.
I use Alt in a few applications and reserve Super for the window manager only.
Find the font name you need with fc-list. For instance, to use JetBrains’ font: fc-list | grep Jet.

General settings

 bash
 
 
 
# launch a terminal
bindsym $mod+Return exec kitty

# launch a terminal in the same directory currently used
bindsym $mod+Shift+Return exec cd "$(xcwd)" && exec kitty

# kill focused window
# ⇒ usual way to close applications
bindsym $mod+Escape kill
bindsym $mod+mod1+Escape --release $exec xkill

# reload the configuration file
# ⇒ apply changes from this file on the fly
bindsym $mod+Shift+c reload

# restart i3 inplace
# ⇒ preserves your layout/session, can be used when upgrading i3
bindsym $mod+Shift+r restart

# exit i3
# ⇒ logs you out of your X session
bindsym $mod+Shift+e $exec i3-msg exit

# resize windows
# you can also use the mouse for that:
# for tiled windows ⇒
 # drag the border with LeftClick or RightClick
# for floating windows ⇒
 # `mod + RightClick`, then drag

# resize without entering "resize mode"
# ⇒ I find this more convenient. I usually don't care about
# precise window sizes, so here the steps are far greater.
# If I want more control, then entering resize mode will do.
bindsym $mod+Control+l resize shrink width 10 px or 10 ppt
bindsym $mod+Control+k resize grow height 10 px or 10 ppt
bindsym $mod+Control+j resize shrink height 10 px or 10 ppt
bindsym $mod+Control+h resize grow width 10 px or 10 ppt

A few notes on the General settings:

Resizing and moving floating windows with the mouse also works great: mod+LeftClick to move around and mod+RightClick to resize. This way, it’s also possible to move windows to other screens.

Screens and monitors

 bash
 
 
 
# lock the screens with a black color background
bindsym $mod+Delete $exec i3lock -c 000000

# hide/unhide i3status bar (laptop)
bindsym $mod+m bar mode invisible bar-0
bindsym $mod+Shift+m bar mode dock bar-0

# hide/unhide i3status bar (monitor)
bindsym $mod+b bar mode invisible bar-1
bindsym $mod+Shift+b bar mode dock bar-1

# set up displays
exec $path-xrandr-both

# use laptop display only (turn off monitor)
bindsym $mod+o exec $path-xrandr-laptop

# use monitor display only (turn off laptop screen)
bindsym $mod+mod1+o exec $path-xrandr-monitor

# use laptop + monitor displays
bindsym $mod+shift+o exec $path-xrandr-both

# disable screen saver
$exec xset s off

# disable power saving
$exec xset -dpms

A few notes on the Screens and monitors section:

It sets keybindings to hide/unhide bars on separate screens, which can be particularly useful when screen sharing without having to enter in fullscreen mode.
It has additional keybindings to turn on/off the displays independently.

Note: I rely on Vim keybindings to move between containers and workspaces as I find the position of those keys on the home row really comfortable to apply to the main window actions one would want to execute.

 bash
 
 
 
# container focuses where the mouse is (yes/no)
focus_follows_mouse no

# go to last urgent workspace
# ⇒ this is the worspace that turns "red" by default when something happens
# in an unfocused workspace, like an application pop-up
bindsym $mod+u [urgent=latest] focus; $center-mouse

# change focus
# ⇒ works in all modes: tabbed, stacked, etc.
bindsym $mod+h focus left; $center-mouse
bindsym $mod+j focus down; $center-mouse
bindsym $mod+k focus up; $center-mouse
bindsym $mod+Down focus down; $center-mouse
bindsym $mod+Up focus up; $center-mouse
bindsym $mod+l focus right; $center-mouse

# move focused window (works in all modes)
bindsym $mod+Shift+h move left; $center-mouse
bindsym $mod+Shift+j move down; $center-mouse
bindsym $mod+Shift+k move up; $center-mouse
bindsym $mod+Shift+l move right; $center-mouse

# for example, switching from workspace 1 to workspace 2 (e.g. mod+2) then
# typing again mod+2 would bring you back to workspace 1 without having to
# remember that you came from workspace 1 in the first place.
workspace_auto_back_and_forth no

# alternate between the last two workspaces that have been used
bindsym $mod+Tab workspace back_and_forth

# move a container (window or group of windows if you grouped them) to the
# "alternate" workspace you visited last
# (the one brought with $mod+Tab in this case)
bindsym $mod+mod1+Tab move container to workspace back_and_forth; \
 workspace back_and_forth

# switch to any window with Rofi
# ⇒ this simulates the familiar behavior of Alt+Tab on Windows and allows you
# to find windows by typing, but uses a better operating system to do it ;).
bindsym Mod1+Tab exec "rofi -theme lb -font $rofi-font \
 -show-icons -width 95 -show window"

# toggle fullscreen mode for the focused container
# ⇒ this hides the i3bar for the current monitor
# ⇒ you can still leave the i3bar hidden and switch to other workspaces
bindsym $mod+f fullscreen toggle

# navigate workspaces next / previous
# ⇒ works for all monitors and will go in increasing order
# if workspaces 1 to 6 are on monitorX and workspaces
# 7 to 10 are on monitorY as in this config, this will switch
# to any workspace where there is at least one container
bindsym $mod+Mod1+l workspace next
bindsym $mod+Mod1+h workspace prev
bindsym $mod+Shift+Right workspace next
bindsym $mod+Shift+Left workspace prev

# the difference with the above is that it limits movements to the
# the current monitor only
bindsym $mod+Right workspace next_on_output
bindsym $mod+BackSpace workspace next_on_output
bindsym $mod+Shift+BackSpace workspace prev_on_output
bindsym $mod+Left workspace prev_on_output

# Bindings to "mark" and "goto" mark specified with 1 character
# ⇒ rarely used, but can still be useful if you have many containers open
bindsym $mod+z exec i3-input -F 'mark %s' -l 1 -P 'Mark: '
bindsym $mod+g exec i3-input -F '[con_mark="%s"] focus' -l 1 -P 'Goto: '

# switch to workspace (no matter which monitor it is set to)
bindsym $mod+1 workspace $ws1
bindsym $mod+2 workspace $ws2
bindsym $mod+3 workspace $ws3
bindsym $mod+4 workspace $ws4
bindsym $mod+5 workspace $ws5
bindsym $mod+6 workspace $ws6
bindsym $mod+7 workspace $ws7
bindsym $mod+8 workspace $ws8
bindsym $mod+9 workspace $ws9
bindsym $mod+0 workspace $ws10

# determine which workspace appears on which screen
# ⇒ with a single output screen, this is not necessary
workspace 1 $output-secondary
workspace 2 $output-secondary
workspace 3 $output-secondary
workspace 4 $output-secondary
workspace 5 $output-secondary
workspace 6 $output-secondary
workspace 7 $output-primary
workspace 8 $output-primary
workspace 9 $output-primary
workspace 10 $output-primary

# move focused container to workspace and switch to workspace
bindsym $mod+Shift+1 move container to workspace $ws1; workspace $ws1
bindsym $mod+Shift+2 move container to workspace $ws2; workspace $ws2
bindsym $mod+Shift+3 move container to workspace $ws3; workspace $ws3
bindsym $mod+Shift+4 move container to workspace $ws4; workspace $ws4
bindsym $mod+Shift+5 move container to workspace $ws5; workspace $ws5
bindsym $mod+Shift+6 move container to workspace $ws6; workspace $ws6
bindsym $mod+Shift+7 move container to workspace $ws7; workspace $ws7
bindsym $mod+Shift+8 move container to workspace $ws8; workspace $ws8
bindsym $mod+Shift+9 move container to workspace $ws9; workspace $ws9
bindsym $mod+Shift+0 move container to workspace $ws10; workspace $ws10

A few notes on the Navigation section:

I like to keep the number of workspaces to 10 because the number row is easily accessible and there’s less context switching involved.
I also like to keep a higher number of workspaces on the main screen I work on as I can use mod+Left and mod+Right to switch focus on that screen only. This is usually to keep a reference opened on the other screen, like server logs.
Those keybindings make it really easy to navigate between workspaces on one particular screen. Even though I like to work with a monitor being higher than the laptop located in front of it to avoid working in a twisted position at all times, this would work fantastically well in the horizontal direction too.
If for whatever reason the main screen is disconnected (power outage or unplugged), I can still use the laptop screen without needing to modify the config file, although with a slightly more limited amount of workspaces. Tip: if a monitor has been disconnected (such as in the power outage scenario), using the keybinding to turn it off will move all the workspaces to the other display(s), so everything will be visible again.

Nice addition to make the mouse follow any focused container

By default, the focus of the mouse in i3 will go to the active screen, but it won’t follow the focus if switching to different containers on the same screen. I found this little hack using the center-mouse script after running commands like move and focus to force the mouse to move to any focused container. For convenience, here is the content of that script. You will need the program xdotool to use it.

Layout

 bash
 
 
 
# set default desktop layout (default is tiling), <stacking|tabbed>
workspace_layout tabbed

# change container layout (stacked, tabbed, toggle split)
bindsym $mod+s layout stacking
bindsym $mod+w layout tabbed
bindsym $mod+e layout toggle split

# start in opposite orientation from your monitor
default_orientation vertical

# toggle split at each new window (Fibonnaci layout)
# note: only useful if the layout is set to `default`
# for_window [class=".*"] split toggle

# toggle the way a split happens in the focused window
bindsym $mod+t split toggle

# toggle tiling / floating
# ⇒ this works on a container with any number of windows!
# if you select multiple windows with `$mod+a` (see below)
# to group them and then toggle them, the whole group will
# either tile or float
bindsym $mod+Shift+space floating toggle

# change focus between tiling / floating windows
# ⇒ If you leave a floating window on top of other tiled windows,
# you can switch the focus from the one on top to the one(s) in
# the background (useful with apps like Zoom or Google Meet that
# you want to keep in the foreground)
bindsym $mod+space focus mode_toggle

# Use Mouse+$mod to drag floating windows
floating_modifier $mod

# toggle sticky for floating windows
bindsym $mod+Shift+s sticky toggle

# focus the surrounding containers
bindsym $mod+a focus parent; $center-mouse
bindsym $mod+c focus child; $center-mouse

A few notes on the Layout section:

To maximize the size of applications, I prefer using the “tabbed” mode, which is more compact than the stacking mode. If I quickly want to split windows side-by-side, I just type mod+e to toggle split vertically by default and if I need a horizontal split, I just toggle again with mod+e.
I don’t use the “grouping” feature with mod+a and mod+c very often, but when I need to move a few windows to another workspace for instance, that’s quite handy!
A floating window in “sticky mode” will follow you on all your workspaces and remember that this mode is enabled even if you put in back in a tiling window and then to a floating window again.

Scratchpad

The scratchpad is sometimes so useful that it deserves its own section! When you send a window to the “scratchpad”, it disappears. Then, with a keybinding, you can bring in back in floating mode on top of any other window on any active workspace you happen to be in. The same keybinding will toggle on/off the display of that scratchpad and if you happen to have sent multiple windows to the scratchpad, activating the same keybinding again will cycle through all the scratchpads as we set a custom mode called Scratchpad in this example.

I often use that for an audio player I leave running in the background and instead of using a whole workspace to leave that window opened, I send it to the scratchpad, which means it doesn’t take any space and I can quickly bring it back in focus whenever I want, in any workspace. I find that having more than three windows in the list of scratchpads becomes cumbersome as you cycle through them, so I keep the scratchpad for specific, infrequent uses for applications that require less attention.

If you want to convert a scratchpad back to a regular tiled container, it’s as easy as triggering “toggle tiling / floating” (in this config file, it happens with mod+Shift+space).

 bash
 
 
 
# Move the currently focused window to the scratchpad.
# First, we toggle floating mode and we resize and position the window to make sure
# it will appear correctly when showing it for the first time.
bindsym $mod+minus floating toggle; resize set $scratchpad-size, \
 move position center; move scratchpad

# Set up scratchpad applications
for_window [class="Audacious"] floating enable
for_window [class="Audacious"] move scratchpad
for_window [class="Audacious"] resize set $scratchpad-size
for_window [instance=$temp-notes] floating enable
for_window [instance=$temp-notes] move scratchpad
for_window [instance=$temp-notes] resize set $scratchpad-size
for_window [instance=$python-term] floating enable
for_window [instance=$python-term] move scratchpad
for_window [instance=$python-term] resize set $scratchpad-size
for_window [instance=$todoist-app-name] floating enable
for_window [instance=$todoist-app-name] move scratchpad
for_window [instance=$todoist-app-name] resize set $scratchpad-size

A note on the Scratchpad section:

In my setup, I have two screens with the same resolution of 1920x1080, so the same “resize” command works on both screens. You might want to use two different keybindings if you want to bring a scratchpad back to a screen with a different resolution.

Borders

 bash
 
 
 
# Configure border style <normal|1pixel|pixel xx|none|pixel>
new_window pixel 5
new_float normal
default_floating_border pixel 5

# Hide borders
hide_edge_borders smart

# change borders
bindsym $mod+Shift+n border none
bindsym $mod+n border pixel 5
bindsym $mod+y border normal 5

A few notes on the Borders section:

I just love knowing which container is active, so I set thick, bright borders with a nice kind of “electric blue” color that’s easy to spot on a light or dark background (colors are set below in the section Colors & theming).
I also love saving space whenever possible to see more stuff on the screen, so I avoid gaps altogether (if you like them, have a look at i3-gaps). In that spirit, I also set the option hide_edge_borders smart so that borders don’t show up when I have only one tiled container covering the whole space.
This also shows that you can have a different border size for floating windows if you find the thickness distracting. Personally, I just find it helps me know which container is active when I toggle from foreground to background window with mod+space.

Bashtop on the left with a dark background, LibreOffice on the right with a light background, Neofetch floating window on top featuring a thick, blue border.

dmenu

dmenu is so useful that it also got its own section. By default, you usually launch applications with mod+d: I kept the same behavior here. I added a few custom launchers that I use all the time to open files based on a topic, using mnemonics that work (for me, at least). If you want to know more about setting these kinds of shortcuts, you may be interested in reading Using dmenu to Optimize Common Tasks ;).

 bash
 
 
 
bindsym $mod+Mod1+b $exec ~/Dropbox/.custom/dmenu/books.sh
bindsym $mod+Mod1+c $exec ~/Dropbox/.custom/dmenu/cheatsheets.sh
bindsym $mod+Mod1+d $exec ~/Dropbox/.custom/dmenu/documents.sh
bindsym $mod+Mod1+e $exec ~/Dropbox/.custom/dmenu/edit_scripts.sh
bindsym $mod+Mod1+f $exec ~/Dropbox/.custom/dmenu/filepaths.sh
bindsym $mod+Mod1+q $exec ~/Dropbox/.custom/dmenu/quotes.sh
bindsym $mod+Mod1+r $exec ~/Dropbox/.custom/dmenu/reading.sh
bindsym $mod+Mod1+s $exec ~/Dropbox/.custom/dmenu/scripts.sh
bindsym $mod+Mod1+u $exec ~/Dropbox/.custom/dmenu/university.sh
bindsym $mod+Mod1+w $exec ~/Dropbox/.custom/dmenu/work.sh
bindsym $mod+Shift+f $exec ~/Dropbox/.custom/dmenu/thunar_launcher.sh
bindsym $mod+Shift+u $exec ~/Dropbox/.custom/dmenu/university_launchers.sh
bindsym $mod+d $exec ~/Dropbox/.custom/dmenu/software.sh

Shortcuts

 bash
 
bindsym $mod+control+r $exec thunar ~/Desktop

# Display multiple time zones around the world
bindsym $mod+Mod1+t $exec ~/Dropbox/.custom/dmenu/times.sh

A few notes on the Shortcuts mini-section:

In i3, you don’t really make use of icons on the desktop. I like the absence of visual clutter it provides, but I sometimes like to access a specific folder in which I drop a few shortcuts/symlinks to access other files from there.
An idea for customization: working remotely with many teammates from around the world is sometimes confusing timewise, so I have a simple script that outputs the current time in the places I’m interested in monitoring.

Simple pop-up with a list of timezones.

Sound

 bash
 
 
 
# `pkill` is useful to quickly update the block in i3blocks
bindsym XF86AudioRaiseVolume exec $volumepath -np up $volumestep -t $statuscmd \
 -u $statussig && pkill -RTMIN+1 i3blocks
bindsym XF86AudioLowerVolume exec $volumepath -np down $volumestep -t $statuscmd \
 -u $statussig && pkill -RTMIN+1 i3blocks
bindsym XF86AudioMute exec $volumepath mute -n -t $statuscmd \
 -u $statussig && pkill -RTMIN+1 i3blocks
bindsym XF86AudioMicMute $exec $toggle-mic-on-off
bindsym $mod+exclamdown $exec $toggle-mic-on-off

# Automatically set the volume to a given value when (re)launching i3
exec_always --no-startup-id "amixer -D pulse set Master 50%"

# Always mute the microphone source when (re)launching i3
exec_always --no-startup-id pactl set-source-mute \
 "alsa_input.pci-0000_03_00.6.analog-stereo" true && \
 pkill -RTMIN+10 i3blocks

This section will depend on the hardware being used, but it gives an idea of how to do things. I use i3-volume to get nice notifications when changing the volume and all the options being set here use i3-volume. Toggling the mic output was not super obvious at first, but it’s obviously doable and it’s good to know there’s an XF86Audio property for that purpose!

Brightness

 bash
 
 
 
# Control brightness more precisely through software `light`
bindsym XF86MonBrightnessDown exec $brightness-laptop-down
bindsym XF86MonBrightnessUp exec $brightness-laptop-up

# Adjust external monitor brightness
bindsym $mod+F2 $exec $brightness-monitor-down
bindsym $mod+F1 $exec $brightness-monitor-up
bindsym $mod+F3 $exec $brightness-monitor-default

# Toggle laptop screen
bindsym $mod+Control+b $exec $brightness-toggle-laptop

To control the screen brightness, I use light. I also like to just toggle the brightness of my laptop at night when I read something on my external monitor, so I use a toggle_laptop_brightness script that I found somewhere online and adapted slightly.

Applications

This section will heavily depend on the software you use of course, but there’s the gist of it. I like to have a shortcut for bashtop to quickly monitor system resources (glances is also quite nice). Besides that, I like to have applications automatically appear on specific workspaces and be switched to in some instances.

Controlling which application opens in floating mode is also useful as some just don’t play that well with tiling. To find information about an application, you can open a new terminal window and launch xprop, click on the window you need information about and voilà, a couple of strings will be displayed like so (output truncated a bit):

	Icon (16 x 16):
	 ▒▓▓▓▓▒
	 ▒▓██████▓▒
	 ▒█▓▒░ ░▒▓█▒
	 ▒█▓░ ░▓█▒
	 ▓▓░ ░░░ ░▓▓
	▒█▒ ░███▓░ ▒█▒
	▓█░ ░░▓█▓ ░█▓
	▓█ ░▓▓██▓ █▓
	▓█ ▓█▒▓█▓ █▓
	▓█░ ▓█▓▓█▓ ░█▓
	▒█▒ ░▓▓▒▓▒ ▒█▒
	 ▓▓░ ░▓▓
	 ▒█▓░ ░▓█▒
	 ▒█▓▒░ ░▒▓█▒
	 ▒▓██████▓▒
	 ▒▓▓▓▓▒
WM_NORMAL_HINTS(WM_SIZE_HINTS):
		program specified location: 0, 0
		program specified minimum size: 627 by 279
		window gravity: NorthWest
WM_CLASS(STRING) = "audacious", "Audacious"
WM_ICON_NAME(STRING) = "47. David Bowie - Best Of Bowie - Heroes (3:36) - Audacious"
WM_NAME(STRING) = "47. David Bowie - Best Of Bowie - Heroes (3:36) - Audacious"

You may need to switch to tiling windows or make the terminal window that launches xprop a floating window to be able to click on the desired window. Here, we get an output for the Audacious music player. You usually need the second string from WM_CLASS(STRING) but if you don’t want to mess with letter casing being upper vs lowercase, you can prefix with (?i) for “insensitive” as shown below and that will match any window containing that pattern. Sometimes, you’re just after matching a “title” (like it’s done with LibreOffice in the snippet of code below) and you can get that one by showing the container’s border. With this config file, the mod+n keybinding will show the border you want at the top and mod+y will make it disappear again.

 bash
 
 
 
# Autostart applications
$exec $brightness-monitor-default
$exec $default-web-browser
$exec $launcher-todoist
$exec brightnessctl s 20%
$exec compton -CG --config /dev/null
$exec nitrogen --restore
$exec nm-applet
$exec pasystray
$exec xfce4-clipman

# First kill it as it doesn't always respect the `--timeout` option otherwise
exec_always --no-startup-id "killall unclutter; unclutter --jitter 40 --ignore-scrolling --timeout 5 &"

# Start
bindsym $mod+Shift+d --release exec "killall dunst; exec notify-send 'restart dunst'"
bindsym $mod+Shift+t exec thunar
bindsym $mod+Shift+w $exec $default-web-browser
bindsym $mod+masculine [instance=$python-term] scratchpad show; move position center
bindsym $mod+Shift+masculine $exec kitty --name ipythonterm -o font_size=22 -e \
 $launcher-python-term -q
bindsym $mod+plus [instance=$temp-notes] scratchpad show; move position center
bindsym $mod+Shift+plus $exec kitty --name tmpnotes -e $launcher-temp-notes
bindsym $mod+p [class="Audacious"] scratchpad show; move position center
bindsym $mod+Shift+p $exec audacious
bindsym $mod+q [instance=$todoist-app-name] scratchpad show; move position center
bindsym $mod+Shift+q $exec $launcher-todoist
bindsym Print --release $exec flameshot gui --path $screenshots-folder
bindsym $mod+Print --release $exec flameshot screen --path $screenshots-folder
bindsym mod1+F3 $exec kitty -e htop

# Open applications on specific workspaces
assign [class="(?i)code"] $ws1
assign [class=$default-web-browser] $ws3
assign [class="(?i)firefox"] $ws3
assign [class=$default-web-browser-class] $ws3
assign [class="Audacity"] $ws4
assign [class="Gimp"] $ws4
assign [class="Inkscape"] $ws4
assign [class="vlc"] $ws4
assign [class="(?i)atril"] $ws6
assign [class="(?i)zathura"] $ws6
assign [title="(?i)libreoffice"] $ws4
assign [class="Transmission"] $ws8
assign [class="keepassxc"] $ws8
assign [class="obs"] $ws8

# Automatically switch to workspace when opening those
for_window [class="(?i)code"] workspace $ws1
for_window [class=$default-web-browser] workspace $ws3
for_window [class=$default-web-browser-class] workspace $ws3
for_window [class="(?i)firefox"] workspace $ws3
for_window [class="Gimp"] workspace $ws4
for_window [class="Inkscape"] workspace $ws4
for_window [class="audacity"] workspace $ws4
for_window [class="vlc"] workspace $ws4
for_window [class="(?i)zathura"] workspace $ws6
for_window [class="(?i)atril"] workspace $ws6
for_window [title="(?i)libreoffice"] workspace $ws4
for_window [class="Transmission"] workspace $ws8
for_window [class="keepassxc"] workspace $ws8
for_window [class="obs"] workspace $ws8

# Open specific applications in floating mode
for_window [class="(?i)virtualbox"] floating enable border pixel 5
for_window [class="GParted"] floating enable border pixel 5
for_window [class="Lightdm-settings"] floating enable pixel 5
for_window [class="Lxappearance"] floating enable sticky enable border pixel 5
for_window [class="Nitrogen"] floating enable sticky enable border pixel 5
for_window [title="File Transfer*"] floating enable border pixel 5
for_window [title="alsamixer"] floating enable border pixel 5
for_window [class="(?i)zoom"] floating enable border pixel 5

The section Autostart applications is the list of applications that launch when you open your X session with i3.

Keyboard & mouse

 bash
 
# Set compose key to Right Ctrl
exec_always --no-startup-id setxkbmap -option $compose-key

# Delay, interval
exec_always --no-startup-id xset r rate 250 60

I like to set those options in my config file as they can be modified on the fly if you reload i3. This is thanks to the exec_always --no-startup-id directive which will always run the invoked command when relaunching, not just when logging in to a session.

Colors & theming

Of interest in this section, apart from the actual colors, is where you will set your i3bar on the screen (top vs bottom) and on which monitor your tray (the space with little icons to show the volume, WiFi connectivity and so on) will be displayed if you have more than one monitor. In this case, the bar displays at the top of the screen à la Mac or à la GNOME with position top and reveals information about system resources with i3blocks (you can find how it can be configured in my dotfiles or in the i3blocks GitHub repo).

 bash
 
 
 
# Start i3bar to display a workspace bar (plus the system information i3status if available)
bar {
 id bar-1
 $font-small
 $output-secondary
 # mode invisible
 tray_output none
 status_command i3blocks
 position top

 colors {
 background #000000
 statusline #ffffff
 separator #666666
# border backgr. text
 focused_workspace #4c7899 #285577 #ffffff #ffffff
 active_workspace #333333 #5f676a #ffffff #3c3b37
 inactive_workspace #333333 #222222 #888888 #aea79f
 urgent_workspace #2f343a #900000 #ffffff #ffffff
 }
}

bar {
 id bar-0
 $font-medium
 $output-primary
 tray_output primary
 status_command i3blocks
 position top
 bindsym button4 nop
 bindsym button5 nop

 colors {
 background #000000
 statusline #ffffff
 separator #666666
# border backgr. text
 focused_workspace #4c7899 #285577 #ffffff #ffffff
 active_workspace #333333 #5f676a #ffffff #3c3b37
 inactive_workspace #333333 #222222 #888888 #aea79f
 urgent_workspace #2f343a #900000 #ffffff #ffffff
 }
}

# Theme colors
# class border backgr. text indic. child_border
 client.focused #ffffff #ff0054 #ffffff #2e9ef4
 client.focused_inactive #333333 #8338ec #ffffff #484e50
 client.unfocused #333333 #000000 #bbbbbb #292d2e
 client.urgent #2f343a #900000 #ffffff #900000
 client.placeholder #F9FAF9 #061229 #FFFFFF #061229
 client.background #000000

What I’ve found particularly useful here is the fact you can have a different “i3 bar” for each screen. I’ve set keybindings in the section Screens and monitors so I can toggle them on/off separately too.

I’ve also switched away from the default i3status program to display the status bar(s) to i3blocks, which I’ve found a lot nicer to look at and easier to configure too.

Theming i3 can be tedious, but thankfully there are tools to automate the process! One such tool is i3-style, which allows you to quickly switch in place your theme without having to log out or modify manually your i3 config file. To go the manual route or to tweak an existing theme, you can always use a website like HTML Color Codes to find an exact hexadecimal value. You can also use terminal.sexy to come up with nice looking themes, which can be exported for other applications you may be using.

Conclusion

You can find the complete config file in my dotfiles on GitHub. If you liked this article, you may also enjoy reading the following ones:

More resources and references

Getting started with the i3 tiling window manager — Fedora Magazine
Official i3 documentation — i3wm.org
i3 page on the Arch Wiki — Arch Wiki

Tip the Scales in Times of Instability With the Rock-Solid Debian

Sébastien Lavoie — Sun, 05 Apr 2020 12:14:00 -0500

Introduction

I’m familiar with Linux distribution hopping, having tried out many options over the years, starting around the time Mandrake 9.2 was popular back in 2003, then switching to a few others including Ubuntu, KNOPPIX, Fedora, Xubuntu, openSUSE, Kubuntu, Mint, Manjaro, Mandriva… And of course Debian along the way, which undoubtedly used to be relatively harder to get started with.

My heart has also been stirred by different desktop environments and window managers, from more user-friendly/feature-rich solutions such as KDE, GNOME (along with Unity when it was still a thing), Xfce and Cinnamon to an arguably more obscure selection comprising Openbox, Fluxbox, Enlightenment, Awesome WM, dwm, i3 and bspwm.

I haven’t tried everything that’s out there (XMonad being one such esoteric possibility), but I’ve come to realize that what matters most to me is a great balance of stability and usability, allowing to be more focused on any given task at end and therefore leading to increased productivity. For this reason, I recently turned back to a fantastic combo: Debian with an Xfce base and the i3 tiling window manager.

Why Debian?

Stability and Reliability

Debian has always been to me the father figure of stability in the Linux world. Countless servers have run on Debian and continue to do so for good reason: it just works once it is properly set up. I have had some bad luck with other Debian-based distributions like Ubuntu and Linux Mint which strive to be easier to use but remain easier to break, being a bit more bleeding edge and sometimes bloated too with tons of software I don’t really need. Fedora, although I like its philosophy and style very much, has always lead to hardware issues on my apparently less-than-ideal machines. Manjaro has been pleasant and easy to use, but Arch feels like the right choice if one is to build a custom system from scratch. It does take a good amount of time to get things going on such a distribution and usually a good dose of maintenance too, which brought me to seek less time-consuming options. For stability and reliability, Debian is hard to beat in my experience.

Marvelous Package Manager

I have always found the package manager on Debian (and derivatives) to be easier to use than alternatives like yum, DNF or urpmi for RPM packages. The pacman package manager available on Arch-based systems is truly excellent and powerful, but I simply find apt to be more intuitive after using it for a lot longer.

It Just Won’t Break

Sitting on the bleeding edge is fun and sometimes even rewarding when things finally work as expected, but I have seen that it doesn’t stay that way forever. Big updates, sometimes relatively frequent ones, can leave the system in an unusable state. It’s often a minor annoyance to fix, but that just doesn’t happen on Debian, where packages are vetted mainly for their legendary stability before releasing them. They are indeed quite a bit older than what can be found on other distributions. It’s the price to pay, but I came to the conclusion that it’s worth it if you’re looking to get things done in the long run.

Debian Xfce in its glorious simplicity.

Xfce Is Minimalist Enough and Hassle-Free

It’s also about the combination of Debian + Xfce: while Debian makes sure the system remains functional as a whole, Xfce is the solution for interacting with applications and windows without glitches in a “floating mode” where all windows can be grabbed and moved around easily. Debian itself keeps old packages around by choice and Xfce has a very slow release cycle yet also provides stability out of the box. This means that installing Xfce on Debian has to work because bugs have been evened out over years of effort from both teams. This is an easy yet very satisfying solution.

Xfce vs KDE

One of the main appeals of desktop environments like KDE and GNOME is that they have more features and add them more often. They do use more resources and even though they have gone through substantial optimizations over the years, they still feel less snappy on older systems compared to simpler window managers or even Xfce. Recently, KDE caught up with Xfce in terms of resources utilization, but there’s one major reason I just can’t rely on it on a production machine: in every single release I have tried (from KDE 2.x in the early 2000s to Plasma 5.x), I was confronted with numerous bugs within minutes of delving into it. I have always been faced with some minor troubles on GNOME too (versions 2 and 3), but it’s never been as severe as with KDE. KDE has plenty of cool ideas and is fully customizable, but that’s to a fault in my view.

Xfce vs GNOME

On the other hand, GNOME does consume at least twice as much RAM and CPU compared with Xfce even with no extensions enabled on GNOME and a couple of plugins activated on Xfce. I enjoy how GNOME deals with virtual desktops and think this can be a great productivity enhancement, but once I’ve configured Xfce to be mainly keyboard-driven, I prefer keeping it simpler with less transition effects and other nice visual additions. On the graphical side of things, GNOME with Wayland has never worked as well for me as with Xorg, so that’s something else to watch for.

Xfce vs i3

Well, i3 is a different beast in its own right and has taken a special place in my heart. It uses less memory and CPU than any desktop environment out there and can be used with minimalistic software, like the st terminal and the dynamic menu dmenu (read the article about suckless tools if that resonates with your style!). There are still a few things that I didn’t like very much about it, such as the way windows are managed in fullscreen mode, the default lack of a convenient master/slave tiling layout (similar to dwm and bspwm) and the way one interacts with external monitor(s), where workspaces use the same numbering across multiple screens. But i3 with Debian feels more mature and is (again) a bit older than what you might find elsewhere. There is a comprehensive section in the i3 User’s Guide that explains how to work around some issues.

I find that maximizing windows works like what you would expect in Xfce, covering everything but the menu bar. There’s also the fact that Xfce makes it very convenient to add and remove virtual desktops on the fly instead of having a bunch of those at all time. With minimal Bash scripting, windows in Xfce can be moved around from one monitor to the other, replicating a useful feature available in i3. Xfce, having only floating windows, behaves better with applications like VirtualBox and GIMP by default. And there’s also some common ground with the “pseudo tiling” available in Xfce which makes i3 much less unique, although i3 makes it a lot easier to maximize the screen estate being used.

Debian i3 using up to the last available pixel.

In the department of customization, i3 is very good, but having to edit a configuration file manually each time a little change is desired can become tiresome. Xfce has a wonderful settings manager which makes it easy to adjust many system settings as well as those related only to the window manager. i3 requires initially quite a bit more effort to work and will incur a few additional dependencies if one wants to make it look better. Xfce strikes a very good balance: it’s highly customizable; pretty much bug-free in my experience and is usable right away without any surprise. Once both are fully configured to match one’s need, I tend to rely on i3 to be more productive and keep Xfce as a functional backup if someone else is going to try to use the mouse on my system to accomplish any kind of useful action with the windows ;).

I find that installing Debian with an Xfce base leads to having enough useful software pre-installed compared to a barebone installation and installing i3 afterwards only makes the transition easier.

Xfce vs Other Window Managers

Now, there is an endless stream of other options to explore and I don’t know enough about many of those to dare to comment. But from those I tried, I can certainly say that I preferred the ease of use of Xfce over other more minimalistic approaches like Openbox, Enlightenment and Fluxbox. Xfce offers all you need out of the box, but not much more, which is what I’m looking for at this moment. On the other hand, making dwm work in one precise way can be tricky and requires many tweaks before the configuration can remain untouched for a while. I do not like the necessity of recompiling the source code every single time a tiny change is made which led me to discard it as a convenient option in the long run. I like making small visual adjustments to my system from time to time and I want this to be as frictionless as possible.

Otherwise, dwm and bspwm might be some very decent options if one is inclined to be tweaking everything from scratch (it’s not really a facultative step anyways!), but Xfce integrates everything one might need under very few different packages and has been extremely reliable for me from the beginning. On any kind of modern machine, the extra system resources used up by Xfce compared to those lighter alternatives really don’t mean much in the end because it is compensated with the presence of useful applets and tools which definitely make one’s life easier.

It’s Ideal for Developers

Resources Efficiency & Effectiveness

Debian with a light working environment is resource-efficient and comes with much less software out of the box compared to the KDE or GNOME editions: instead, more resources are available for hungry applications like heavy IDEs. Installing applications specific to those desktop environments work flawlessly too. Not only does Debian consume less resources (especially while running Xfce/i3 on top), it does so extremely well and offers great performance.

Debian Xfce mostly at rest.

Rock-Solid Stability (Again, Big Selling Point!)

Since it’s so stable, any release of Debian is currently supported for at least 3 years and up to 5 years for LTS (Long Term Support) releases, which means one doesn’t have to worry about constantly upgrading the system. For a start, upgrading packages on the stable branch of Debian very rarely leads to a broken system, unlike on more bleeding edge distros like Fedora or Manjaro where downloading a few months old release almost guarantees some unexpected challenges.

Packages Availability

With currently close to 58,000 packages offered on Debian, there’s a very good chance that anything one might need will be available. Working with up-to-date, proprietary applications like Google Chrome, Zoom or Slack is also pain-free: most companies, when they do consider Linux, opt for sharing a classic deb package, the format used on Debian and Debian-based systems. Some of those packages can also be found or added directly to the sources managed by the package manager, allowing for easy, automatic updates.

Synaptic, the legendary package manager.

Large Community with Freedom in Mind

Because no company backs Debian directly, it relies on a community effort to keep going and it has done so for a long time, having now hundreds of distributions being based on it. This means that it’s easy to find a ton of documentation and tutorials giving solutions taking into account Debian-based systems. One will be able to fix any issue cropping up thanks to the Debian User Forums and of course thanks to the immense popularity of Ubuntu, which contributes tremendously to making answers available in its forums and in the Stack Exchange network.

Resources to Get Started

Debian Documentation
Debian User Forums
Debian Wiki
Developer-oriented: resources for contributing to Debian
Cloud-oriented: tutorials for Debian on Digital Ocean
i3 tiling window manager
Xfce Desktop Environment

Conclusion

After trying many different Linux distributions and desktop environments, I keep coming back to what satisfies me best in the end: stability and usability. Debian feels a bit old, but at the same time one knows it delivers on what it promises. The same can be said for Xfce and i3. This is also what makes them such a good combo: despite not being cutting edge in the realm of features, there’s no way it could break as easily as KDE or GNOME, particularly on less stable distributions. There are still a few rough edges when it comes to customizing both Xfce and i3 in my opinion, but when looking for something that just works and will keep doing so, Debian is hard to beat.

Using dmenu to Optimize Common Tasks

Sébastien Lavoie — Sun, 10 Nov 2019 09:02:00 -0600

Introduction

dmenu is one of those tools that look a little unimpressive at first but can accomplish so much! It’s a program that you can use to receive any output redirected from other programs (through pipes in the terminal, the symbol |) and treat that output so that it can pop up within a simple menu to make it available for execution. If you want to know more about other fantastic tools from suckless.org, I went over some of them before, such as the st terminal and slock, a dead simple screen locker.

Any Simple Example?

You bet! Before diving in with how to install it and some more concrete examples, you could give dmenu a go with a simple command such as the following (assuming the program is installed on your machine).

bash

ls | dmenu

This will effectively “pipe” the output of ls into dmenu and a menu like the following would appear (by default, it shows as a thin stripe at the top covering the width of the screen):

If you start typing, the displayed list will be filtered down like so:

You can also switch to the next item to be highlighted by typing Ctrl + n, to the previous item by typing Ctrl + p and exit by reaching for the Escape key. For now, if you type Enter once your desired selection is highlighted, the selection will be outputted to the terminal and that will be the end of it. Let’s convert this into a practical thing, then.

Keeping the same output as before which only contained directories, we could open a file manager (here, I’m going with pcmanfm) and do something like this (bear with me, the explanation follows!):

 bash
 
ls | dmenu -l 5 | xargs -I {} pcmanfm "{}"

This is now a fully functional example, albeit its practicality is debatable. What will happen, exactly?

First, ls will output a list of directories in the current working directory. That is, the following would be printed in the terminal without any piping:

Desktop Downloads Learning Pictures Public Templates virtualbox_vms
Documents Dropbox Music Programming SortOut Videos

When we pipe this into dmenu, we will get a menu with all that output nicely formatted vertically, which is what the -l 5 options does (here, we want only 5 lines to show). We will see a maximum of 5 items as this is the value we passed to the -l option:

We can still start typing a word that doesn’t show up in this list like Mu and we will see that this list is filtered to only include the matching directory Music even though we couldn’t see it before since we limited our results to 5 items. We could also use the same technique with Ctrl + n and Ctrl + p to cycle between the elements.

Up to this point, we are getting our selection outputted to the terminal. Next, we pipe it into xargs, which will allow us to specify a command to which we will pass our result (what is printed to the terminal) as an argument (we could make use of more arguments depending on the output we get, but let’s start simple). The -I {} option will make it possible to “quote” our result so it is read as a single argument and properly escaped. This means that without this option, if we have spaces or other special characters in the argument (such as a folder called My Music), it would try to pass each word as a new argument to pcmanfm, trying to open both My and Music directories at once.

We are representing our output as {} and when we quote it with pcmanfm "{}", spaces are interpreted without any trouble. If we wanted to use various arguments instead, we could try something like this:

 bash
 
echo "file1.txt file2.txt\nfile3.txt file4.txt" | dmenu -l 2 | xargs cat

The part before the first pipe character will print to the terminal those two lines:

file1.txt file2.txt
file3.txt file4.txt

When we pipe this into dmenu -l 2, we will get this menu:

Typing Enter on one of the highlighted items would then trigger xargs to pass the content literally to cat as arguments, which would then print to the terminal the content of both file1.txt and file2.txt (the first line containing two arguments for cat) or the content of both file3.txt and file4.txt (the second line also containing two arguments for cat) in succession.

Now that we got our feet wet with what dmenu does (displays a menu), we might want to install it.

How do You Install It?

In Manjaro Linux, it comes with i3 if you use that flavor of the distribution and can be opened by pressing the modifier key (either Super/Windows key or Alt key) along with the letter d, as in the shortcut mod + d, or by typing dmenu_run in a terminal, which will present a list of installed applications to launch. Otherwise:

Debian-based (such as Ubuntu)

bash

sudo apt install dmenu

Arch-based (such as Manjaro)

bash

pacman -Syu dmenu

You can also install it from your distribution’s package manager if available or from source.

Useful Real-World Examples

Here are a couple of ways I like to use dmenu to open a menu with a list of:

cheat sheets;
filesystem paths;
most used documents;
documents & books I read at the university;
custom scripts I want to run in the background.

Here are a few screenshots of how it currently looks like in my daily usage so you get a better idea.

Cheat sheets

University shortcuts

File manager shortcuts

So, how does that all work? As a starting point, all of those menus are launched through a specific keyboard shortcut that uses a mnemonic for each one (mod being the “modifier” key on i3, which is set to Super/Windows):

mod + Alt + c: cheat sheets;
mod + Alt + d: documents;
mod + Alt + f: file manager;
mod + Alt + s: scripts;
mod + Alt + u: university.

Let’s take the cheat sheets example, which is a bit more interesting since it launches different applications.

Setting Up a Custom Command

Configuration for i3 (bind a keyboard shortcut)

Here, I’m using i3 to set a keyboard shortcut to run a specific command, but this will be a similar experience on other window managers and desktop environments.

 bash
 
 
 
# i3config file
# The backslash at the end of the line allows us
# to split the line to increase readability

## Cheatsheets

bindsym $mod+Mod1+c exec --no-startup-id \
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

You would usually be able to launch a custom command from your environment through a keyboard shortcut. If passing a direct command such as the above one isn’t an option, you can always store it in a Bash script and run that Bash script instead as the designated custom command. The script would then contain the following:

 bash
 
#!/bin/bash

## Cheatsheets
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

As far as i3 is concerned, that’s all you need to do. You would need to reload the configuration file (by default: i3config) where the previous bindsym command has been set up to apply the changes (default shortcut to reload: mod + Shift + c).

Configuration for cheatsheets.conf

The content of this file is literally what will be shown when dmenu opens it. An excerpt:

 
#---------- Cheat Sheets -------------------------------------------------------
bash st -e nvim path/to/bash.sh
git zathura path/to/github.pdf
vimwiki firefox path/to/vimwiki.html

Here, we have set a maximum of 30 lines to be displayed (-l 30). What follows after an element has been selected with dmenu allows us to parse the content of the line and retrieve only the command we are interested in with sed before passing that filtered content around to sh to execute it as a shell command. With more complex commands requiring multiples arguments to be received, we could add one more pipe between sed and sh like this (or with xargs -I {} to avoid problems with spaces):

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | xargs -r | sh

If the line we want to run only includes a path to a file as in:

myshortcut path/to/file.pdf

We could instead pipe it into an external command of choice if the same program applies to all items presented in the menu, say Firefox:

 bash
 
cat path/to/file.conf \
| dmenu -l 30 | sed 's/.* \+//' | xargs -I {} firefox "{}"

What’s nice with the way pipes work in a Unix-like system is that we can chain harmless commands until the very end so they will simply be printed to the terminal. In this example, if we want to see how to filter our lines before running a command, we can do so as follow.

Pipe 1

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30

If you remember from the menu we saw earlier, there’s a shortcut to open a cheat sheet for Git. Let’s say we selected that one with dmenu. Because our command isn’t doing anything with the result, it will be outputted to the terminal like so (just like in the excerpt of cheatsheets.conf):

bash

git zathura path/to/github.pdf

What sed does here is to cut everything from the beginning of the line up to where the command starts (that’s where we find zathura, which is a powerful document viewer), because we need to isolate that part of the line so it looks like a shell command we could run on its own. Let’s add a new pipe to our command and see what sed does with it*.

* _{We could have used other tools to parse the string like awk, grep, cut, etc.}

Pipe 2

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//'

If we select the same item as before with dmenu to illustrate more clearly what this new addition does, we will get this output:

bash

zathura path/to/github.pdf

If we were to type this in the terminal (assuming the file exists and zathura is installed!), that would do the trick and it would open with the specified document viewer. Pipe 2 and subsequent pipes before we execute something is where the filtering magic happen. In short:

Everything before | dmenu is how our input will look like when we run dmenu;
Everything after | dmenu [options here] | is what we need to do to our input so that it is converted into a working shell command;
Finally, what comes after the last pipe (either xargs, sh or a combination of both) is our way to redirect our string to the shell so it can be executed.

Once we are visually satisfied with how our command is supposed to look like (it has to be something that works when typed directly in the terminal), the next step is to pipe it again so it can be executed.

Pipe 3

 bash
 
cat path/to/cheatsheets.conf \
| dmenu -l 30 | sed 's/.* \+//' | sh

There we go, the command is launched. If we keep the same simple syntax in all of our .conf files —or whatever extension we choose— where the content of our menus is stored in plain text, we can quickly and painlessly create keyboard shortcuts to run custom lists of commands that can be edited on the fly. Once our shortcuts are active, it’s only a matter of editing one of those .conf files and automatically our lists will be up-to-date when we trigger the shortcut again.

Running a Custom Script

If we want to run custom scripts, we need to indicate a command that would work in the terminal, such as python myscrypt.py or ./myscript.sh. When it comes to shell scripts, we have to make sure they are executable. We can do so through a file manager or within the terminal like this:

bash

chmod +x path/to/script.sh

This will add the necessary permissions for the user to execute the script. As we already know, we would then need to add a keyboard shortcut to launch our custom menu and store our command in a file like scripts.conf that would contain the following:

#---------- scripts.conf -------------------------------------------------------
myscript script.sh

And that’s all there is to know to get piping with dmenu! You may also find this video from Luke Smith on YouTube to be quite helpful as well, which is where the inspiration for this post came from. He also posted a complementary video about adding prompts to your commands which is a nice way to add interactivity to your scripts!

Chaining dmenu prompts

Another useful scenario is when you want to take a specific action based on the output of a previous command. For instance, let’s say you want to read a book but when you choose a pdf with dmenu, you want to be prompted for which reader to use while you want to let the system choose the default application for other types of files (e.g. epub or mobi). This could be achieved with a script similar to the following one:

 bash
 
 
 
#!/bin/bash
FILE=`find ~/Documents/calibre_library -type f -iname "*.pdf" -o \
 -iname "*.epub" -o -iname "*.mobi" | dmenu -l 30`

if [[ "$FILE" == *.pdf ]]
then
 READER=`echo -e "zathura\natril" | dmenu -i -p "Which reader?"`
 $READER "$FILE"
else
 xdg-open "$FILE"
fi

Here’s what’s happening:

We find all the files (-type f)
in the directory ~/Documents/calibre_library
that match a pattern that’s case-insensitive with -iname (here, ending in either pdf, mobi or epub)
matching one file at a time (-o can be interpreted to mean “only” and will keep searching if the previous file extension was not matched)
then presenting 30 lines (-l 30) of results at a time with dmenu
then, if the file is a PDF, prompts whether to use atril or zathura as the file reader and open with the chosen program
otherwise, open the file with the default application.

Customize the Look of dmenu

As they say, “beauty is in the eye of the beholder”. If you would rather make some changes to how dmenu look, you can. dmenu will be searching for the configuration file located at ~/.dmenurc, which could contain something as put below (with this configuration, it will look like the screenshots shown previously):

 bash
 
 
 
#
# ~/.dmenurc
#

# define the font for dmenu to be used
DMENU_FN="NotoSans-10.5"

# background colour for unselected menu-items
DMENU_NB="#161925"

# textcolour for unselected menu-items
DMENU_NF="#fdfffc"

# background colour for selected menu-items
DMENU_SB="#235789"

# textcolour for selected menu-items
DMENU_SF="#fdfffc"

# command for the terminal application to be used:
TERMINAL_CMD="st -e"

# export our variables
DMENU_OPTIONS="-fn $DMENU_FN -nb $DMENU_NB -nf $DMENU_NF -sf $DMENU_SF -sb $DMENU_SB"

Conclusion

Hopefully this introduction to what dmenu has to offer gave you some ideas. I hope you’ll find many ways to adapt the examples so you can benefit from this amazing tool. You can find more configuration details in my dotfiles on GitHub for anything related to i3, dmenu, zathura, st, slock and many more useful programs.

Have a good time automating your digital life!

Using i3 as a Window Manager for Increased Productivity

Sébastien Lavoie — Tue, 08 Jan 2019 11:12:00 -0600

What is i3?

i3 is a tiling window manager. To get to know i3 better, it’s good to situate what desktop environments are in the first place.

What are desktop environments?

If you are familiar with Linux, you certainly know about desktop environments such as GNOME, KDE, Xfce… and actually many more are available (you can see this article on Wikipedia for an extended selection)! The classic Graphical User Interface (GUI) on Windows XP was known as Luna and is now called Modern on Windows 10. Aqua is the name of the GUI on macOS. Well, every desktop environment comes with a window manager, the main component that makes interactions with windows possible, like moving, resizing, minimizing or closing them.

Desktop environments are very useful in many ways:

They are usually very easy to set up as they come fully functional out of the box. Like opening a user session on macOS or Windows.
They are sometimes quite customizable, but you don’t have to change anything to get them to work, as they normally set default applications to open with certain file types.
They automatically integrate services such as WiFi network detection, automatic mounting of drives when you plug them in, etc.
You can enable virtual desktops to split your work across different spaces. This concept can grow to [Activities](https://docs.kde.org/trunk5/en/kde-workspace/plasma-deskto p/activities-interface.html), which is a feature implemented in KDE that allows you to use virtual spaces literally for different activities by having settings that are specific to each activity (like launching one application or keeping widgets in determined positions), plus the ability to use multiple virtual desktops inside each activity.
They integrate with applications that are specifically designed to take advantage of the desktop environment in question by adapting colors and themes perfectly to match the general look of the system and arranging settings in a common location for all applications.

Why use a window manager like i3?

Even though desktop environments are user-friendly and include many goodies, they do have several disadvantages that make window managers great alternatives.

Less bloated

Desktop environments are often bloated with many applications that you may not need but that are nevertheless occupying system resources as they have many dependencies. For example, if you use Thunderbird for managing your emails and your desktop environment is GNOME, try to remove Evolution, the default application for emails that comes with it… It’s still relatively easy to disable its processes, but you sometimes have to configure files manually to satisfy your need for removing clutter.

Lower memory and CPU consumption

Other than coming with a set of default applications (more disk space), the whole environment occupies a lot more memory to run smoothly. On my modest laptop, I was still experiencing speed issues because the system was occupying too much RAM when opening heavy applications (lots of tabs when web browsing, photo editing, loading IDEs like PyCharm for programming, etc.) and I had 4 GB of RAM installed at the time. KDE requires at least 600 MB, same is true for GNOME in most recent versions (but used to be over 1 GB not very long ago, just like for KDE). Windows, for example, requires more than 1.5 GB of RAM to operate with basic features. i3 needs less than ~15 MB with as many windows and spaces open as you would ever want. Since there are much less processes to take care of, CPU consumption is also lower, which is more noticeable on older machines.

Keyboard efficiency

There are obviously ways to go about using keyboard shortcuts for pretty much anything you want with desktop environments. However, window managers and especially i3 make this a must, as there is really no reason to use a mouse for moving windows.

First of all, windows are “stuck” in place and never overlap by default. You can’t move them around with a mouse unless they are “floating” windows, which means you can separate them to move them around freely like in most desktop environments. The whole point of using a window manager like i3 is to maximize screen space, so every window opens in full screen. Honestly, the only time I ever found the need to use a floating window with i3 is when using the operating system Windows in a virtual environment when connecting through RDP with Google Chrome on Google Cloud Platform (that is, not very often). Other than that, I find it very practical to split the screen with no overlapping windows, even with my small 15 inches screen.

Because windows are managed the way they are in i3, getting split when multiple windows are in the same workspace and never overlapping, it nurtures the good habit of dividing workspaces appropriately to maximize the space that each application occupies, which is done with keyboard shortcuts. With (customizable) shortcuts, you can split windows, move them to other workspaces, change workspaces, open applications automatically in specific workspaces, etc. Using exclusively the keyboard to manage the windows becomes a huge time saver, and even more so when considering the very small footprint required to use the window manager, making for a lightning fast experience.

Extremely fast customization

Once you get past the initial lack of visual appeal and weird way to move around, you can actually customize many aspects of i3, including fonts, mouse bindings, window border decorations, colors, automatic execution of apps when initiating a session, etc.

Why is it so fast to customize? Because the configuration is all contained in one simple text file and you can make a change and reload the window manager on the fly to see your changes being reflected. Setting the number of workspaces is as easy as adding or removing a line (well, as a bare minimum, otherwise it’s useful to also bind certain keyboard shortcuts to move to those newly created workspaces). Setting a wallpaper is one line, setting a screen lock is another one. Quick and efficient.

Easy to switch layouts and focus

I actually enjoy the default layout quite a lot, in which there exists no overlap between windows (they split as needed) and all windows are visible at the same time in each workspace. If you need to make more space for a window, you can either “focus” on the current window, which will make it full screen and cover every pixel of the screen, or you can move particular windows to other workspaces. This last option will automatically resize windows so that they occupy the maximum space available.

Besides the default layout, you can also stack and tab windows, depending on how you like to work (it is well worth having a look at the i3 user’s guide to see the many other features available). Personally, I prefer seeing everything at once and dividing my work into many workspaces. If you are curious, here is how I currently have my workspaces set up:

Programming — Exclusively for programming purposes.
Terminals — For working in the terminal, opening another instance of a terminal text editor, etc.
Web — Just for Internet. Always full screen unless I open some website that requires to open new windows (like banking), which conveniently split the windows. The web browser automatically launches in the background when opening a session in i3.
Multimedia — Editing photos or watching videos.
Music — ncmpcpp (terminal music player) automatically launches in the background when opening a session.
Experiments — I use this workspace when trying to understand some programming concepts with an interactive IPython console or for breaking the system in one way or another because I don’t know what I’m doing.
Fix — After realizing that sometimes experiments need to be cleaned up a bit, I now use this workspace exclusively to run tools in the background, such as BleachBit for cleaning files or glances (similar to the top command) for watching how the system is doing.
Words — I use that workspace for reading e-books or for writing, either in Neovim or LibreOffice depending on the task.
Tools — This workspace is reserved for anything that I might want to have access to once in a while, like a calendar or KeepassXC for accessing a password database.
sg — I mainly use that workspace to update this very website, but I also use it for setting up local web servers for making personal projects in Flask and Django or even just a temporary server with python -m http.server to share files with other devices on the local network.

Only workspaces that contain windows will appear on the screen at any given time and are automatically created when you access and use them.

What does it look like in action?

Here is a screenshot* of the workspace where this article is being written (click to open):

* _{In this particular scenario, the splits on the right side are
intentionally very small as I do not need to read the output, but need
quick access to a terminal to enter commands. Moving back and forth
between windows is a breeze, so that’s how I currently handle the
situation.}

Note: With Neovim, there is an embedded terminal, which makes things very easy to handle by avoiding splits altogether. In that case, it is also possible to divide a workflow with tabs inside Neovim instead of physically splitting windows.

Alternatively, instead of splitting windows, a more convenient solution on smaller screens might be to use stacking windows with the shortcut $mod + s in each workspace or, to provide that behavior by default, the following can be added to i3’s configuration file (defaults in ~/.config/i3/config):

 bash
 
# Set default container layout
workspace_layout stacking

Conclusion

I am not trying to convince myself anymore: I really prefer this workflow! If you are looking for a change and would like to maximize both your productivity and your system resources, i3 is a great window manager to consider. It doesn’t seem very intuitive at first, but I swear it quickly becomes easy to use and you also end up learning more about how Linux works and set things up manually (just once!) to your likings. For example, I use Rofi instead of dmenu to have a window pop-up to select applications or switch to any window on any workspace… which was only one line to modify in the configuration file.

I have found the following screencasts on YouTube to be quite useful in learning how to configure i3 (apart from the official documentation which is very comprehensive):