There are two different low-level tools that you can use to configure keyboard support in X. The older tool is called xmodmap and the newer tool is called setxkbmap. My experience is that setxkbmap has less of a learning curve and is far easier to use, as long as it supports what you want to do. It’s what I currently use.

The best way to make use of setxkbmap is via the localectl command from SystemD. For instance, I currently configure my own keyboard with the following command:

$ sudo localectl set-x11-keymap us pc105 "" ctrl:nocaps,esperanto:qwerty,lv3:ralt_switch,compose:rwin

From left to right, this specifies that:

• I am using a us keyboard model.
• My keyboard has a pc105 layout.
• I am not specifying a keyboard variant. (The empty quotes are a placeholder.)
• I am specifying several options:
  • ctrl:nocaps - Make the CapsLock key function as a Ctrl key.
  • esperanto:qwerty - Make the accented letters of Esperanto easily accessible via the AltGr key.
  • lv3:ralt_switch - Make the right Alt key function as AltGr.
  • compose:rwin - Make the right Windows key function as the Compose key.

The localectl set-x11-keymap command persistently configures X for you, so it can be run once at system installation. In order to select among keyboard models, layouts, variants, and options, one can read the man page for xkeyboard-config or use the following commands:

• localectl list-x11-keymap-models
• localectl list-x11-keymap-layouts
• localectl list-x11-keymap-variants [layout]
• localectl list-x11-keymap-options

With the localectl set-x11-keymap command above, if I am typing something in Esperanto, I can type a ĉ by holding down AltGr (the right Alt key) and pressing c. The other accented characters for Esperanto are keyed in similarly. If I am typing in German then I can create a ü character by holding down the Compose key (the right Windows key) while typing a " character, then releasing and typing a u character. Similarly, if I am writing something in French and want to type a ç, I need only hold down the Compose key while pressing the , key, then release and type a c. This works quite well for my purposes.

In the past I have tried to use a version control system to manage my dotfiles, but it always failed. The reason it failed is that the files either live directly in your home directory or are scattered among several different subdirectories in your home directory. Making your home directory itself a checkout of a git repository is impractical because there are a lot of directories and files in there that you don’t want to live in version control.

Eventually I came across the idea of using GNU Stow to manage my dotfiles. GNU Stow is a tool for creating and managing symlinks. In the past the tool was commonly used to switch between multiple versions of a particular software package. With the advent of package managers that particular application of GNU Stow has become less common, but the tool remains useful for managing dotfiles.

Suppose you want to manage your bash, emacs, screen, ssh, and X dotfiles. In your home directory, these files look something like this:

/home/username
|---- .bashrc
|---- .emacs.d
|   |---- init.el
|---- .screenrc
|---- .ssh
|   |--- config
|---- .xinitrc
|---- .xmodmaprc
|---- .Xresources

Let’s reproduce this structure using GNU Stow. First create a git repository called .dotfiles in your home directory, and inside that repository create the directories bash, emacs, screen, ssh, and X. Next copy the dotfiles from your home directory into .dotfiles so that you have a structure that looks like the following:

/home/username/.dotfiles
|---- bash
|   |---- .bashrc
|---- emacs
|   |---- .emacs.d
|       |---- init.el
|---- screen
|   |---- .screenrc
|---- ssh
|   |---- .ssh
|       |--- config
|---- X
|   |---- .xinitrc
|   |---- .xmodmaprc
|   |---- .Xresources

Now cd into .dotfiles and run

for d in $(ls)
do
    stow $d
done

Et voilà! At this point GNU Stow has deployed the symlinks and your dotfiles are under version control. Note also that your dotfile symlinks may be scattered all over your home directory when deployed, but your .dotfiles repository keeps the files themselves neatly organized.

When I need to set up to work on a new machine I simply checkout .dotfiles in the home directory, cd into .dotfiles, and again run the for loop. Now the new machine is configured to my liking.