Emacs initialisation file (dotemacs)

An integral part of my custom desktop session on GNU/Linux

Created: 2019-08-15
Updated: 2020-03-28, 07:21 +0200.
See this file's upstream git history. Everything is part of my dotfiles' repository.

Table of Contents

1 Overview

1.1 Canonical links to this document

1.2 What is this

The present document, referred to in the source code version as emacs-init.org, contains the bulk of my configurations for GNU Emacs. It is designed using principles of "literate programming": a combination of ordinary language and inline code blocks. Emacs knows how to parse this file properly so as to evaluate only the elisp ("Emacs Lisp") included herein. The rest is for humans to make sense of my additions and their underlying rationale.

Literate programming allows us to be more expressive and deliberate. Not only we can use typography to its maximum potential, but can also employ techniques such as internal links between sections. This makes the end product much better for end users, than a terse script.

In more practical terms, this document is written using org-mode. It contains all package configurations for my Emacs setup. To actually work, it needs to be initialised from another file, that only covers the absolute essentials.

1.2.1 Contents of my init.el

The emacs-init.org is actually loaded from an other file, named init.el as per the Emacs convention. Mine is designed to add the community-driven MELPA archive to the list of package repositories, configure use-package and then load the file with my configurations (i.e. the present document).

For reference, these were the contents of my init.el prior to Emacs 27.1.

(require 'package)
(setq package-enable-at-startup nil)
(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/"))
(unless package--initialized (package-initialize))

(require 'org)
(org-babel-load-file (expand-file-name "~/.emacs.d/emacs-init.org"))

Whereas in Emacs 27.1 and onward, they are modified thus:

(require 'package)

(add-to-list 'package-archives
             '("melpa" . "https://melpa.org/packages/"))

;; Initialise the packages, avoiding a re-initialisation.
(unless (bound-and-true-p package--initialized)
  (setq package-enable-at-startup nil)

;; Make sure `use-package' is available.
(unless (package-installed-p 'use-package)
  (package-install 'use-package))

;; Configure `use-package' prior to loading it.
  (setq use-package-always-ensure nil)
  (setq use-package-always-defer nil)
  (setq use-package-always-demand nil)
  (setq use-package-expand-minimally nil)
  (setq use-package-enable-imenu-support t))

  (require 'use-package))

(require 'org)
(setq vc-follow-symlinks t)
(org-babel-load-file (expand-file-name "~/.emacs.d/emacs-init.org"))

Starting with Emacs 27.1, an early-init.el is now required to control things with greater precision. Its code is as follows:

;; Do not initialise the package manager.  This is done in `init.el'.
(setq package-enable-at-startup nil)

;; Do not resize the frame at this early stage.
(setq frame-inhibit-implied-resize t)

These adjustments are of paramount importance due to changes in the way Emacs initialises the package manager. Prior to Emacs 27.1, the init.el was supposed to handle that task by means of calling package-initialize. Whereas for Emacs 27.1, the default behaviour is to start the package manager before loading the user's init file. This can create unexpected results with regard to how existing configuration files are parsed—or at least that was my experience with certain settings not being parsed consistently (was not able to reproduce it reliably). I prefer the old behaviour so I simply tell the early-init.el to defer the process of initialising the package manager to when init.el is evaluated.

1.2.2 About `use-package'

This is a tool that streamlines the configuration of packages. It handles everything from assigning key bindings, setting the value of customisation options, writing hooks, declaring a package as a dependency for another, and so on.

Though it might not be readily apparent, a "package" in Emacs parlance is any elisp file that is evaluated by Emacs. This includes libraries that are shipped with the upstream distribution as well as code that comes from other sources.

Unlike a typical extensible program, there is no real distinction between native Emacs code and the one that comes from third parties. There is no externally-facing limited set of features that other tools can plug into. Emacs is an interpreter of lisp (Emacs Lisp), meaning that any elisp is evaluated in real time, making Emacs behave in accordance with it.

I have an hour long presentation about switching to Emacs, where this and other topics are discussed in greater detail. It is good to understand the context in order to appreciate the differences between the various use-package declarations documented herein.

The two main functions of use-package:

  1. To install and set up external packages. Those are denoted by the inclusion of :ensure t.
  2. To configure default packages. No :ensure t for them.

With use-package we can improve the start-up performance of Emacs in a few fairly simple ways. Whenever a command is bound to a key it is configured to be loaded only once invoked. Otherwise we can specify which functions should be autoloaded by means of the :commands keyword.

Furthermore, and if absolutely necessary, I define all variables that are supposed to be immutable with the :custom keyword. This writes them to the custom.el that I specify further below. Consider that to be the exception, as all minor modes, custom functions, or other configurations are enabled under the :config keyword. The activation of a mode should always be the very last thing, once all variables have been set.

The following snippet of elisp sets up and configures use-package to my liking. It is already referenced in the previous section concerning the contents of my init.el. This is due to changes in how Emacs 27.1 starts up. Whereas before I used to configure use-package from inside this document.

;; Setup `use-package'
(unless (package-installed-p 'use-package)
  (package-install 'use-package))

;; Should set before loading `use-package'
  (setq use-package-always-ensure nil)
  (setq use-package-always-defer nil)
  (setq use-package-always-demand nil)
  (setq use-package-expand-minimally nil)
  (setq use-package-enable-imenu-support t))

  (require 'use-package))

Settings that do not have a corresponding package are declared using the special use-package emacs notation.

1.2.3 About the source code version of this document

In the org-mode version of this document, I make sure that the above-referenced code blocks are not declared as an emacs-lisp source but rather as mere examples, so they are not accidentally parsed by the actual setup.

Actual code blocks are wrapped between #+begin_src and #+end_src tags (not visible in the website version of this page). For Emacs 27.1, such templates can be quickly inserted with C-c C-, (this works both for empty blocks and active regions). For more on the matter, refer to Org's section further below.

As for the various settings included herein, you can learn even more about them by using Emacs' built-in documentation (great for discovering new features and pieces of functionality).

1.3 Where I run Emacs

My OS is mostly Debian 10 'buster' (the current stable), though I also work on a Void Linux machine. My Emacs is built from source, using the emacs-27 branch. Normally I would be using the packages provided by my GNU/Linux distribution but am opting for the manual method instead in order to make sure my Modus themes are compatible with changes upstream.

I do not optimise for portability across different versions or operating systems. I do, nonetheless, provide inline comments when a certain option or configuration is specific to a yet-to-be-released version of Emacs.

1.4 Note about my methodology

I choose external packages only after I try the defaults. The idea is to take things slowly and learn along the way, while consulting the official manual and relevant documentation. This is necessary to make an informed decision about what is actually missing and what could be improved further.

The process of learning the internals of Emacs means that I will, at times, write my own elisp functions. External packages that I do use are either a clear upgrade over the defaults or otherwise extend the functionality of what is already available. You will not find any superficialities herein: no rainbow-coloured mode lines, no icons, nothing.

Though a former Vim user, I decided not to use evil-mode or any kind of Vi emulation. I wanted to do things differently in order to ultimately set on the best approach going forward. I have eventually settled on a system that builds on top of the "Emacs way" to key bindings. I believe that a mnemonics-based set of keys is easier to memorise and to expand considerably, especially in light of Emacs' multitude of applications beyond the narrow confines of editing text.

1.5 Note about the use of the Super key

Some sections of this document assign functions to s-KEY. The lower case s represents the "Super" key, also known as the "Windows key" on some commercial keyboards. In most cases, those key bindings are alternative ways of invoking common commands that are by default bound to otherwise awkward key chords. The original keys will continue to function as intended (for example, C-x o is also s-o).

To find all my keybindings of this sort in the source code version of this document from inside of Emacs, do M-s o (or M-x occur) followed by the pattern "s-[a-z]".

Note that your choice of desktop environment might render some of these useless. The DE will simply intercept the key chord before it is ever sent to Emacs. For example, GNOME has a hidden key mapping to s-p, which does something with monitors (last time I checked on GNOME 3.30). Such bindings are scattered throughout the config database that is normally accessed with gsettings on the command line or the graphical dconf-editor.

Similarly, a tiling window manager that binds practically all of its motions to Super, will cause you trouble. Personally, I have enabled the Hyper key and am now using it as an extra modifier for controlling my bespoke BSPWM setup (comprehensive documentation in this commit).

1.6 Note about the source file

If you are reading the source code for this file (available in my dotfiles repo on Gitlab), you will notice some metadata tags specific to org-mode below each heading. These are generated by the functions that are defined in the package declaration for org-id. The idea is to keep anchor tags consistent when generating a new HTML version of this document.

This metadata also makes it possible to create immutable internal links, whenever a reference is needed. To create such links, you can use C-c l to capture the unique ID of the current section and then C-c C-l to create a link (the former is defined in the Org package declaration—this is an internal link in action).


Copyright (c) 2019-2020 Protesilaos Stavrou <info@protesilaos.com>

This file is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.

This file is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this file. If not, see http://www.gnu.org/licenses/.

2 Base settings

This section contains the relatively few configurations that are needed prior to the setup of everything else.

2.1 Always rebuild init

When Emacs expands this org-mode file into the actual elisp code, it creates a new document: emacs-init.org derives emacs-init.el. The latter holds my customisations in the state they were in at the time the document was created. Any updates require a rewrite.

To make sure that I do not load older settings after having made some tweaks to my dotemacs, I want to delete that derived file when I instruct Emacs to terminate its process. This ensures that edits I made to emacs-init.org are parsed into a new emacs-init.el at the next startup.

For live evalutation of elisp, we have C-x C-e (eval-last-elisp).

(use-package emacs
  (defun prot/delete-emacs-init ()
    (let ((configs "~/.emacs.d/emacs-init.el"))
      (when configs
        (delete-file configs))))
  :hook (kill-emacs . prot/delete-emacs-init))

2.2 Edit modeline "lighters"

In Emacs speak, the name of a mode present at the modeline is called a "lighter". For example, Flyspell's lighter is "Fly".

With this package we can edit or rename lighters, or altogether hide them (the information is still available when running C-h m). Furthermore, the functionality can be integrated in every package declaration of use-package: you will see a :delight tag.

(use-package delight
  :ensure t
  :after use-package)

2.3 Custom.el

When you install a package or use the various customisation interfaces to tweak things to your liking, Emacs will append a piece of elisp to your init file. I prefer to have that stored in a separate file.

(use-package cus-edit
  (setq custom-file "~/.emacs.d/custom.el")

  (unless (file-exists-p custom-file)
    (write-region "" nil custom-file))

  (load custom-file))

2.4 Base typeface configurations

While we can always specify a font family for each Emacs "face" (i.e. customisable styles of code/interface constructs), it still is a good idea to establish a baseline for what typeface settings should be applicable by default. In general, I like consistent typography and would only mix styles when it is absolutely necessary to convey a particular meaning.

Any font I choose must support Latin and Greek character sets, be readable at both small and large sizes, preferably offer roman and italic variants with corresponding bold weights, not be too thin, not have too short of an x-height, not be too compact or wide, not have a name that directly advertises some brand, not try to call too much attention to its details, and be equally readable against light and dark backdrops.

While there are many good free/libre options available, only a handful of them cope well with my fairly demanding needs. Some look good at large point sizes. Others lack Greek characters. While a few of them are virtually unreadable when cast on a light background (bitmap fonts in particular, including the otherwise sublime Terminus).

My choice of font is a patched version of Hack that I prepared myself, using the latest dev sources from the upstream distribution (fonts built on 2020-02-25). My changes pertain to the use of glyphs that are more suited to roman or italic letter forms respectively. The project's README offers a comprehensive description of the modifications and their underlying rationale.

If I could not patch Hack, I would still use the upstream version. There are, however, some other options that I could consider. Here they are in order of preference, with a short note on what disqualifies them:

Typeface Subjective faults
Hack See the README of my mod
Iosevka Wide glyphs (‘m’, ‘w’) need more work
DejaVu Sans Mono A bit worse than Hack in a lot of details
Source Code Pro Too light, too wide, better with dark themes
Fira Mono/Code No italics, otherwise excellent

Lastly, note that on a modern GNU/Linux system that uses the fontconfig library, per-user fonts are stored in ~/.local/share/fonts.

2.4.1 Primary font settings

Moving on to my configurations, the functions that follow the pattern prot/SCOPE-font allow me to conveniently define the settings I need to use in the given context. Their docstrings should offer you all the information you need.

Each font declaration can accept several fontconfig parameters, as shown in prot/fixed-pitch-params. Read the relevant spec for further details, while also noting that only a subset of these are supported by most typefaces. The parameters we can pass here are treated as exceptions to environment-wide rules that one can specify for fontconfig at the user or system level.

(use-package emacs
  (setq x-underline-at-descent-line nil)
  (setq underline-minimum-offset 0)

  (defconst prot/fixed-pitch-font "Hack"
    "The default fixed-pitch typeface.")

  (defconst prot/fixed-pitch-params ":hintstyle=hintslight"
    "Fontconfig parameters for the fixed-pitch typeface.")

  (defun prot/default-font (family size)
    "Set frame font to FAMILY at SIZE."
     (concat family "-" (number-to-string size) prot/fixed-pitch-params) t t))

  (defun prot/laptop-fonts ()
    "Fonts for the small laptop screen.

Pass desired argument to `prot/font-sizes' for use on my
small laptop monitor."
    (when window-system
      (prot/default-font prot/fixed-pitch-font 10.5)))

  (defun prot/desktop-fonts ()
    "Fonts for the larger desktop screen.

Pass desired argument to `prot/font-sizes' for use on my larger
desktop monitor (external display connected to my laptop)."
    (when window-system
      (prot/default-font prot/fixed-pitch-font 11)))

  (defun prot/reading-fonts ()
    "Fonts for focused reading sessions."
    (when window-system
      (prot/default-font prot/fixed-pitch-font 12.5)))

  (defun prot/screencast-fonts ()
    "Fonts for screen casts and video demos.

Pass desired argument to `prot/font-sizes' for use during screen
casting.  The idea is to make it easier for viewers to see what I
am doing."
    (when window-system
      (prot/default-font prot/fixed-pitch-font 16)))

  (defun prot/presentation-fonts ()
    "Fonts for presentations and video blogs.

Pass desired argument to `prot/font-sizes' for use during
presentations.  Also see `prot/org-presentation'."
    (when window-system
      (prot/default-font prot/fixed-pitch-font 18)))

  (defun prot/fonts-per-monitor ()
  "Use font settings based on screen size.

Choose between `prot/laptop-fonts' and `prot/desktop-fonts'
depending on the width of the monitor.  The calculation is based
on the maximum width of my laptop's screen.  So if an external
display is attached, then it is considered a desktop scenario.

While this function is interactive, it is best to run it with the
`after-init-hook' or perhaps some other event that tracks
monitor-related events."
    (when window-system
      (if (<= (display-pixel-width) 1366)

  :hook (after-init . prot/fonts-per-monitor)) Typeface suitability test

Here is a simple test I have come up with to make an initial assessment of the overall quality of the font: can you discern the character at a quick glance? If yes, your choice of typeface is good prima facie, else search for something else.

Note that this test is not perfect, since many typefaces fall short in less obvious ways, such as the space between the characters. Also note that the website version of this document may not accurately represent the typeface I am using.


Sample character set
Check for monospacing and Greek glyphs


3 Selection candidates and search methods

3.1 Completion framework and extras

As discussed in my video about Emacs' buffer and window management, the optimal way of using Emacs is through searching and narrowing selection candidates. Spend less time worrying about where things are on the screen and more on how fast you can bring them into focus. This is, of course, a matter of realigning priorities, as we still wish to control every aspect of the interface.

Since the day I switched to Emacs (July 2019), I was using some completion framework other than the default. I started out with ivy and its companion packages, switched to the built-in ido and then went back to the former. I never experimented with any sort of customisations to the generic minibuffer experience. Nor did I ever bother with the oldest built-in tool of the sort (icomplete) that is designed to complement the minibuffer's internal mechanisms for matching items. Not until ~10 February 2020…

It turns out that, despite appearances to the contrary, the defaults are very powerful, opening up a range of possibilities to those eager to learn and experiment (a common theme in Emacs).

In the following package declarations I am defining several functions that enhance the experience of icomplete. These are part of a learning process to (i) explore the internal of Emacs and study how various problems are solved with elisp, and (ii) determine how far one can go, in terms of efficient functionality, without deviating from the norms inherent to the tools that are shipped with Emacs.

What this also means is that I am deprecating Ivy and its dependants as well as reviewing any other package that expected their presence or somehow contributed to them. I do understand, however, that some users may still need to see the code and customisations I had for those, thus I am keeping everything in place with the :disabled keyword. Everything is under the heading of important configurations that I stopped using.

3.1.1 Minibuffer essentials and Icomplete (built-in completion)

The minibuffer is the locus of extended command interaction. Whether it is about offering input to a prompt, performing a search, executing a function by its name, the minibuffer remains at the epicentre. The default experience is far more powerful than it seems to be. It can get even better by tweaking the available customisation options and defining our own extensions.

While icomplete is the tool that offers incremental completion feedback for what the minibuffer is doing (where appropriate). There is no added layer of complexity. Just a visualisation of what is going on under the hood. As such, icomplete is designed with the generic minibuffer in mind. The two are meant to work in tandem in accordance with the design conventions of the upstream Emacs distribution.

Now some comments about my implementation:

  • The key bindings in the pattern of s-KEY follow the principles I outlined in my introductory note about the use of the Super key.
  • The flex option in completion-styles and relevant places is only available for Emacs versions after 27. As of this writing (2020-02-10) the current stable release is 26.3.
  • The completion-category-overrides provide exceptions to the fallback completion styles.
  • The completions-format concerns the layout of the *Completions* buffer that pops up after trying to complete a non-unique match. By default, it can be focused directly with M-v while inside an icomplete prompt.
  • To enhance the experience of the Completions buffer, I define several keys that make motions easier and consistent with other read-only interfaces. The h key calls a command of mine for seeking help for the item at point, typically a function or a variable. I also define M-v to take you back to the minibuffer while inside the *Completions* (and s-v to do it from anywhere else).
    • The placement of the Completions, Help, and other buffers is defined in detail in the section about Window rules and basic tweaks, specifically within the display-buffer-alist.
  • I enable recursive minibuffers. This practically means that you can start something in the minibuffer, switch to another window, call the minibuffer again, run some commands, and then move back to what you initiated in the original minibuffer. To exit such recursive edits, hit C-] (abort-recursive-edit). The minibuffer-depth-indicate-mode will show an indicator next to the minibuffer prompt if a recursive edit is in progress.
  • The values of all variables that pertain to the delay of feedback are tentative. My initial tests suggest that they behave exactly the way I want, but this might change once I test them further.
  • For versions of Emacs above 27, there is a mode called fido (Fake IDO, where ido is an alternative option). This changes some of the primary key bindings and commands of icomplete so that it meets the expectations of Ido users. It is not meant as a fully fledged replacement for Ido, as its scope is much narrower (for the time being). If you are curious, check the source code for both icomplete and ido with M-x find-library.
  • All my functions that somehow extend the functionality of Icomplete have their own documentation. No need to reproduce it here. An exception must be made for prot/icomplete-yank-kill-ring that uses a function to avoid sorting the elements of its list. I adapted that sorting method from the dotemacs of GitHub user jixiuf, following a comment I got from them on my video demo of Icomplete (2020-02-26).

An important note about every prot/icomplete-* function that contains a setq in its body: the way the variables are declared is not robust, because it assumes default values that may not exist. I am aware that it is possible to perform tests inside a setq and return their result, but this added complexity is not needed for my case: I know the default values of those variables and keep them constant. If the variables need to be changed, then the functions will be updated accordingly. At any rate, some examples of better toggle design can be discovered in the isearch.el library with M-x find-library isearch.

Also check my configurations pertaining to the minibuffer history. After about one month of full time usage (as of 2020-03-02), I am confident in the built-in mechanism's ability to sort things well enough and to surface the results I am most likely interested in, based on previous selections. This means that we do not need a third-party scoring and filtering library like prescient or amx.

Now here is the actual code for the minibuffer part (icomplete is further below):

(use-package minibuffer
  (setq completion-cycle-threshold 3)
  (setq completion-flex-nospace nil)
  (setq completion-pcm-complete-word-inserts-delimiters t)
  (setq completion-pcm-word-delimiters "-_./:| ")
  ;; NOTE: flex completion is introduced in Emacs 27
  (setq completion-show-help nil)
  (setq completion-styles '(partial-completion substring initials flex))
  (setq completion-category-overrides
        '((file (styles initials basic))
          (buffer (styles initials basic))
          (info-menu (styles basic))))
  (setq completions-format 'vertical)   ; *Completions* buffer
  (setq enable-recursive-minibuffers t)
  (setq read-answer-short t)
  (setq read-buffer-completion-ignore-case t)
  (setq read-file-name-completion-ignore-case t)
  (setq resize-mini-windows t)

  (file-name-shadow-mode 1)
  (minibuffer-depth-indicate-mode 1)
  (minibuffer-electric-default-mode 1)

  (defun prot/describe-symbol-at-point (&optional arg)
    "Get help (documentation) for the symbol at point.

With a prefix argument, switch to the \\*Help\\* window.  If that
is already focused, switch to the most recently used window
    (interactive "P")
    (let ((symbol (symbol-at-point)))
      (when symbol
        (describe-symbol symbol)))
    (when current-prefix-arg
      (let ((help (get-buffer-window "*Help*")))
        (when help
          (if (not (eq (selected-window) help))
              (select-window help)
            (select-window (get-mru-window)))))))

  (defun prot/focus-minibuffer ()
    "Focus the active minibuffer.

Bind this to `completion-list-mode-map' to M-v to easily jump
between the list of candidates present in the \\*Completions\\*
buffer and the minibuffer (because by default M-v switches to the
completions if invoked from inside the minibuffer."
    (let ((mini (active-minibuffer-window)))
      (when mini
        (select-window mini))))

  (defun prot/focus-minibuffer-or-completions ()
    "Focus the active minibuffer or the \\*Completions\\*.

If both the minibuffer and the Completions are present, this
command will first move per invocation to the former, then the
latter, and then continue to switch between the two.

The continuous switch is essentially the same as running
`prot/focus-minibuffer' and `switch-to-completions' in
    (let* ((mini (active-minibuffer-window))
           (completions (get-buffer-window "*Completions*")))
      (cond ((and mini
                  (not (minibufferp)))
             (select-window mini nil))
            ((and completions
                  (not (eq (selected-window)
             (select-window completions nil)))))

  :bind (("s-f" . find-file)
         ("s-F" . find-file-other-window)
         ("s-d" . dired)
         ("s-D" . dired-other-window)
         ("s-b" . switch-to-buffer)
         ("s-B" . switch-to-buffer-other-window)
         ("s-h" . prot/describe-symbol-at-point)
         ("s-H" . (lambda ()
                      (let ((current-prefix-arg t))
         ("s-v" . prot/focus-minibuffer-or-completions)
         :map completion-list-mode-map
         ("h" . prot/describe-symbol-at-point)
         ("n" . next-line)
         ("p" . previous-line)
         ("f" . next-completion)
         ("b" . previous-completion)
         ("M-v" . prot/focus-minibuffer)))

And the following is for the completion interface. Do not forget to also check the section on the minibuffer history.

Note that while running M-x shell, you can still use icomplete by means of tab-completion, but to confirm a choice you need to hit C-m. Hitting RET after successful tab completions will just give you the final part of the candidate. I have yet to figure out why we cannot lock in the entire sequence and why my prot/icomplete-force-complete-and-exit does not work as intended.

(use-package icomplete
  (setq icomplete-delay-completions-threshold 0)
  (setq icomplete-max-delay-chars 0)
  (setq icomplete-compute-delay 0)
  (setq icomplete-show-matches-on-no-input t)
  (setq icomplete-hide-common-prefix nil)
  (setq icomplete-prospects-height 1)
  (setq icomplete-separator " · ")      ; mid dot, not full stop
  (setq icomplete-with-completion-tables t)
  (setq icomplete-in-buffer t)

  (fido-mode -1)                        ; Emacs 27.1
  (icomplete-mode 1)

  (defun prot/icomplete-show-vertical (&optional str)
    "Allow `icomplete' to present results vertically.

This is meant to be used by other functions that need to show
their results as a vertical list, with an optional string marking
the demarcation line.

For an interactive version see `prot/icomplete-toggle-vertical'."
    (when (bound-and-true-p icomplete-mode)
      (setq icomplete-prospects-height 10)
      (if str
          (setq icomplete-separator
                (concat "\n" (propertize str 'face 'shadow) "\n "))
        (setq icomplete-separator "\n "))))

  (defun prot/icomplete-restore-horizontal ()
    "Restore `icomplete' to its horizontal layout.

This is meant to be run by the `minibuffer-exit-hook'."
    (unless (string= icomplete-separator " · ")
      (setq icomplete-prospects-height 1)
      (setq icomplete-separator " · ")))

  (defun prot/icomplete-recentf ()
    "Open `recent-list' item in a new buffer.

The user's $HOME directory is abbreviated as a tilde."
    (let ((files (mapcar 'abbreviate-file-name recentf-list)))
       (completing-read "Open recentf entry: " files nil t))))

  (defun prot/icomplete-font-family-list ()
    "Add item from the `font-family-list' to the `kill-ring'.

This allows you to save the name of a font, which can then be
used in commands such as `set-frame-font'."
     (completing-read "Copy font family: "
                      (print (font-family-list))
                      nil t)))

  (defun prot/icomplete-yank-kill-ring ()
    "Insert the selected `kill-ring' item directly at point.

Sorting of the `kill-ring' is disabled.  Items appear as they
normally would when calling `yank' followed by `yank-pop'.

Defaults to a vertical layout.  This is restored on exit by means
of `prot/icomplete-restore-horizontal'."
    (let ((kills                    ; do not sort items
           (lambda (string pred action)
             (if (eq action 'metadata)
                 '(metadata (display-sort-function . identity)
                            (cycle-sort-function . identity))
                action kill-ring string pred)))))
      (prot/icomplete-show-vertical "··········")
       (completing-read "Yank from kill ring: " kills nil t))))

  (defun prot/icomplete-toggle-vertical ()
    "Toggle vertical view for `icomplete'.

This is intended as a temporary adjustment of the layout,
possibly to read a list of long names.  It is for this reason
that `prot/icomplete-restore-horizontal' exists and is called by
the `minibuffer-exit-hook'.

NOTE: there still needs to be a way to show the minibuffer input
on its own line while also displaying the list of candidates."
    (when (and (minibufferp)
               (bound-and-true-p icomplete-mode))
      (if (not (string= icomplete-separator "\n "))
            (setq-local icomplete-prospects-height 10)
            (setq-local icomplete-separator "\n "))
        (setq icomplete-prospects-height 1)
        (setq icomplete-separator " · "))))

  (defun prot/icomplete-toggle-flex ()
    "Toggle between flex and partial-completion (regexp)."
    (when (and (minibufferp)
               (bound-and-true-p icomplete-mode))
      (if (not (eq (car completion-styles) 'flex))
            (setq-local completion-styles '(flex initials substring partial-completion))
            (message "%s" (propertize "Prioritising FLEX" 'face 'highlight)))
        (setq-local completion-styles '(partial-completion substring initials flex))
        (message "%s" (propertize "Prioritising PREFIX REGEXP" 'face 'highlight)))))

  (defun prot/icomplete-toggle-basic ()
    "Toggle between basic and partial-completion (regexp)."
    (when (and (minibufferp)
               (bound-and-true-p icomplete-mode))
      (if (not (eq (car completion-styles) 'basic))
            (setq-local completion-styles '(basic))
            (message "%s" (propertize "Prioritising BASIC matching" 'face 'highlight)))
        (setq-local completion-styles '(partial-completion substring initials flex))
        (message "%s" (propertize "Prioritising PREFIX REGEXP" 'face 'highlight)))))

  (defun prot/icomplete-force-complete-and-exit ()
    "Complete the current `icomplete' match and exit the minibuffer.

Contrary to `icomplete-force-complete-and-exit', this will
confirm your choice without complaining about incomplete matches.

Those incomplete matches can block you from performing legitimate
actions, such as defining a new tag in an `org-capture' prompt.

In my testing, this is necessary when the variable
`icomplete-with-completion-tables' is non-nil, because then
`icomplete' will be activated practically everywhere it can."

  (defun prot/icomplete-kill-ring-save (&optional arg)
    "Expand and save current `icomplete' match to the kill ring.

With a prefix argument, insert the match to the point in the
current buffer and switch focus back to the minibuffer."
    (interactive "*P")
    (when (and (minibufferp)
               (bound-and-true-p icomplete-mode))
      (kill-new (field-string-no-properties))
      (when current-prefix-arg
        (kill-new (field-string-no-properties))
        (select-window (get-mru-window))
        (insert (car kill-ring))

  :hook (minibuffer-exit . prot/icomplete-restore-horizontal)
  :bind (("s-y" . prot/icomplete-yank-kill-ring)
         ("s-r" . prot/icomplete-recentf)
         :map icomplete-minibuffer-map
         ("C-n" . icomplete-forward-completions)
         ("<right>" . icomplete-forward-completions)
         ("<down>" . icomplete-forward-completions)
         ("C-p" . icomplete-backward-completions)
         ("<left>" . icomplete-backward-completions)
         ("<up>" . icomplete-backward-completions)
         ("<return>" . prot/icomplete-force-complete-and-exit)
         ("M-o w" . prot/icomplete-kill-ring-save)
         ("M-o i" . (lambda ()
                      (let ((current-prefix-arg t))
         ("C-M-|" . prot/icomplete-toggle-vertical)
         ("C-M-," . prot/icomplete-toggle-flex)
         ("C-M-." . prot/icomplete-toggle-basic)))

3.1.2 Completion for projects and directory trees

These are a set of commands for interacting with version-controlled directories, aka "projects", or directory trees in general. With these I have no need for the third-party "Projectile" package.

Some of the functions furnished herein are built into Emacs, while others are defined by me to satisfy my particular needs.

Everything I have here presupposes a completion framework, so make sure to check the previous section on Minibuffer essentials and Icomplete.

Concerning the design of these key bindings, they are consistent with all "advanced search methods" (e.g. the default M-s o for occur).

Note that project-find-regexp produces an xref buffer from where one can run a query-replace on the results by hitting r. If the intention is to make complex changes, consider project-query-replace-regexp instead. There also are other techniques which are project-agnostic, such as multi-occur, ibuffer-do-occur, dired-do-find-regexp-and-replace. Read their respective docs (with C-h f FUNCTION).

Also see my configurations for ripgrep.

(use-package project
  (defun prot/find-file-from-dir-recursive ()
    (let* ((file-list (directory-files-recursively default-directory "" nil))
           (files (mapcar 'abbreviate-file-name file-list)))
       (completing-read "Find file recursively: " files nil t))))

  (defun prot/find-project ()
    "Use `dired' for sub-directory at ~/Git/Projects.

Allows you to switch directly to the root directory of a project
inside a given location."
    (let* ((path "~/Git/Projects/")
           (dotless directory-files-no-dot-files-regexp)
           (project-list (project-combine-directories
                          (directory-files path t dotless)))
           (projects (mapcar 'abbreviate-file-name project-list)))
      ;;;; Enables vertical completion while using `icomplete'.  I do
      ;;;; not need this right now, since there is only a handful of
      ;;;; projects and all of them are in the same path so that a
      ;;;; couple of key presses give a unique match anyway.
      ;; (when (bound-and-true-p icomplete-mode)
      ;;   (prot/icomplete-show-vertical))
       (completing-read "Find project: " projects nil t))))

  :bind (("M-s p" . prot/find-project)
         ("M-s f" . project-find-file)
         ("M-s z" . prot/find-file-from-dir-recursive)
         ("M-s r" . project-find-regexp)
         ("M-s C-M-%" . project-query-replace-regexp)))

3.1.3 In-buffer completions Dabbrev and hippie-expand (dynamic word completion)

This is Emacs' own approach to text completion inside the buffer: "dynamic abbreviation" and the corresponding "do what I mean" wrapper called hippie-expand. The latter is a superset of dabbrev.

After trying the popular third-party "Company" package, I felt that it does not offer me much of an added value, while its popup feature detracted from the otherwise frugal aesthetics of my setup. Whereas Dabbrev works in a way I find intuitive enough, while it remains minimalist in its presentation.

To learn about hippie-expand-try-functions-list, read the introductory remarks in M-x find-library RET hippie-exp RET. The M-/ is bound by default to Dabbrev, but I am repurposing it for its built-in superset.

The dabbrev-abbrev-char-regexp is configured to match both regular words and symbols (e.g. with hyphenation like this variable). This makes it suitable for code and ordinary language.

While the dabbrev-abbrev-skip-leading-regexp is instructed to also expand words and symbols that start with any of these: $, *, /, =. This regexp may be expanded in the future, but the idea is to be able to perform completion in contexts where the known word/symbol is preceded by a special characters. For example, in the org-mode version of this document, all inline code must be placed between the equals sign. So now typing the =, then a letter, will still allow me to expand text based on that input.

To check what I have on regular expressions, see further below my configurations and documentation for re-builder and visual-regexp.

(use-package dabbrev
  :commands (dabbrev-expand dabbrev-completion)
  (setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
  (setq dabbrev-abbrev-skip-leading-regexp "\\$\\|\\*\\|/\\|=")
  (setq dabbrev-backward-only nil)
  (setq dabbrev-case-distinction nil)
  (setq dabbrev-case-fold-search t)
  (setq dabbrev-case-replace nil)
  (setq dabbrev-check-other-buffers t)
  (setq dabbrev-eliminate-newlines nil)
  (setq dabbrev-upcase-means-case-search t))

(use-package hippie-exp
  :after dabbrev
  (setq hippie-expand-try-functions-list
  (setq hippie-expand-verbose nil)
  :bind ("M-/" . hippie-expand)) Simple abbreviations

This section stores all the "skeletons" I define. These are snippets of text, typically templates or code statements, that are meant to speed up typing. I combine them with abbreviations.

Please note that these will be very simplistic at first. I am aware that they can be abstracted using elisp—need to learn more on that front. Also note that wherever you see " _ " it signifies the position of the cursor after the skeleton has been inserted.

(use-package abbrev
  (setq abbrev-file-name "~/.emacs.d/abbrevs")
  (setq only-global-abbrevs nil)

  ;; simple skeletons ;;
  (define-skeleton protesilaos-com-skeleton
    "Adds a link to my website while prompting for a possible
    "Insert website extension: "
    "https://protesilaos.com/" str "")
  (define-abbrev global-abbrev-table "meweb"
    "" 'protesilaos-com-skeleton)

  (define-skeleton protesilaos-gitlab-skeleton
    "Adds a link to my GitLab account while prompting for a
  possible extension.  Makes it easy to link to my various git
    "Website extension: "
    "https://gitlab.com/protesilaos/" str "")
  (define-abbrev global-abbrev-table "megit"
    "" 'protesilaos-gitlab-skeleton)
  :hook ((text-mode . abbrev-mode)
         (git-commit-mode . abbrev-mode)))

3.2 Configurations for—or extensions to—built-in search commands

These are meant to enhance the functionality of tools that are already shipped with Emacs.

3.2.1 Isearch enhancements

The built-in search mechanism is a thing of beauty: minimal in its presentation, powerful in its applications.

I use isearch all the time for quick navigation, either to a visible part of the buffer or to some specific string I am aware of. It also is essential when used in the context of a keyboard macro, as demonstrated in my video about Isearch powers in keyboard macros (2020-01-21).

Run C-h k C-s to get an awesome help menu with all the extra keys you can use with isearch. These are the ones I use the most:

Key chord Description
C-s C-w Search char or word at point
M-s . Similar, but broader match
M-s o Run `occur' on regexp
M-s h r Highlight regexp
M-s h u Undo the highlight
C-s M-r Toggle regexp search
M-% Run `query-replace'
C-M-% `query-replace-regexp'

Many commands can be invoked while running isearch to operate on the current match. For example, C-s SEARCH M-s o will produce an "Occur" buffer with the contents of the search terms. Absolutely great!

With regard to the replace commands, note that you can use them on the active region. Furthermore, you do not need to confirm each action, but can instead type ! to answer "yes" to all possible replacement. Better only use this while having already limited the results to the active region, to some specialised editable buffer like the one of occur, or by using Emacs' narrowing techniques, such as narrow-to-region.

In the package declaration below, the combined effect of the variables for whitespace is a valuable hack: typing a space is the same as inserting a wildcard, which is much more useful as far as I am concerned. A single space represents a wildcard that matches items in a non-greedy fashion. This concerns regular searches (the standard C-s and C-r). The regexp functions C-M-s and C-M-r remain in tact. You can always toggle whitespace matching behaviour while performing a search, with M-s SPC (revert back to just literal spaces).

Now on to some custom functions, all of which are derived from the source code of isearch (do it with M-x find-library RET isearch RET). Here is an overview of what goes into this package declaration.

Mark isearch match
Replaces the default mark command following a successful search. I prefer to mark the match. This can be then used to insert multiple cursors (if you are using it), kill the region, etc. Besides, it is always possible to mark a region from point to search string by running C-x C-x following a successful search.
Move to opposite end
Isearch places the point at either the beginning or the end of the match, depending on the direction it is moving in. For single words or balanced expressions this is not an issue because you can always confirm a search by using a motion key (so, for example, move to the end of the matching word with M-f). There are, however, matches that are not limited to such boundaries. For those cases moving to the opposite end might require multiple key presses, which is bad when trying to record an efficient keyboard macro. prot/isearch-other-end addresses the issue. It is bound to C-RET while running a successful search. The direct inspiration is this forum answer. Note though that you can achieve the same result by changing the direction the search is moving towards with C-s or C-r (though I still prefer my minor addition).
Delete non-match
The built-in method to remove the entirety of a mismatched input is to hit C-g following a failed search. This keeps the valid part and allows you to continue searching. However, I find that the choice of key binding can prove problematic, since C-g also exits a standard/successful search. As such, the simple function prot/isearch-abort is designed to remove the entirety of a mismatch, just by hitting backspace (aka DEL). For valid searches, backspace functions exactly as expected, deleting one character at a time. Note, though, that it is no longer possible to delete part of a failed search, just by hitting backspace: you can still rely on C-M-d for that (or edit the input with M-e).
Replace symbol at point
Combine the built-in functions of isearch-forward-symbol-at-point and isearch-query-replace-regexp into a single command that is bound to the key chord M-s %. Simple and super effective (pro tip: hit ! to answer "yes" to all possible matches, which is possible in all cases where Emacs asks you for multiple confirmations).

The variables about the lazy count that are commented as "Emacs 27.1" effectively supersede the functionality of anzu, a package I once used.

(use-package isearch
  (setq search-highlight t)
  (setq search-whitespace-regexp ".*?")
  (setq isearch-lax-whitespace t)
  (setq isearch-regexp-lax-whitespace nil)
  (setq isearch-lazy-highlight t)
  ;; All of the following variables were introduced in Emacs 27.1.
  (setq isearch-lazy-count t)
  (setq lazy-count-prefix-format "(%s/%s) ")
  (setq lazy-count-suffix-format nil)
  (setq isearch-yank-on-move 'shift)
  (setq isearch-allow-scroll 'unlimited)

  (defun prot/isearch-mark-and-exit ()
    "Mark the current search string and exit the search."
    (push-mark isearch-other-end t 'activate)
    (setq deactivate-mark nil)

  (defun prot/isearch-other-end ()
    "End current search in the opposite side of the match.
Particularly useful when the match does not fall within the
confines of word boundaries (e.g. multiple words)."
    (when isearch-other-end
      (goto-char isearch-other-end)))

  (defun prot/isearch-abort ()
    "Remove non-matching `isearch' input, reverting to previous
successful search and continuing with the search.

This is a modified variant of the original `isearch-abort',
mapped to C-g which will remove the failed match if any and only
afterwards exit the search altogether."
    (while (or (not isearch-success) isearch-error)

  (defun prot/isearch-query-replace-symbol-at-point ()
    "Run `query-replace-regexp' for the symbol at point."

  :bind (("M-s M-o" . multi-occur)
         ("M-s %" . prot/isearch-query-replace-symbol-at-point)
         :map minibuffer-local-isearch-map
         ("M-/" . isearch-complete-edit)
         :map isearch-mode-map
         ("M-/" . isearch-complete)
         ("C-SPC" . prot/isearch-mark-and-exit)
         ("DEL" . prot/isearch-abort)
         ("<C-return>" . prot/isearch-other-end)))

3.2.2 Regular expressions: re-builder and visual-regexp

To learn more about regular expressions, read the relevant pages in the official manual. Assuming you have this installed properly on your system, run C-h r i regexp to get to the starting chapter.

Also watch my ~35 minute-long primer on Emacs regexp (2020-01-23).

Emacs offers a built-in package for practising regular expressions. By default, re-builder uses Emacs-style escape notation, in the form of double backslashes. You can switch between the various styles by using C-c TAB inside of the regexp builder's buffer. I choose to keep this style as the default. Other options are string and rx.

(use-package re-builder
  (setq reb-re-syntax 'read))

Another option (though the two are not mutually exclusive) is to use the third-party package visual-regexp. This one is meant as a drop-in replacement for query-replace (and the regexp variant). I prefer not to use it that way, but only invoke it via M-x when I need to test a regular expression that I would then replace with something else. The major upside of this tool is that it highlights groups individually and offers a live preview of the replacement, making it absolutely great when dealing with complex sets of regexp constructs.

(use-package visual-regexp
  :ensure t
  (setq vr/default-replace-preview nil)
  (setq vr/match-separator-use-custom-face t))

3.2.3 wgrep (writable grep)

With wgrep we can directly edit the results of a grep and save the changes to all affected buffers. In principle, this is the same as what the built-in occur offers. We can use it to operate on a list of matches by leveraging the full power of Emacs' editing capabilities (e.g. keyboard macros, multiple cursors…).

(use-package wgrep
  :ensure t
  (setq wgrep-auto-save-buffer t)
  (setq wgrep-change-readonly-file t))

3.2.4 ripgrep (rg.el)

This is a package that allows us to interface with the external command line program called "ripgrep".

What I find particularly appealing about rg.el is that it follows the interface paradigms of built-in Emacs functions, such as grep or occur. With regard to the latter, it even uses the same key to convert the results' buffer into an editable one: e (the ability to write changes is provided by the wgrep package that I define right above).

Furthermore, rg.el interfaces with ibuffer, another built-in package, to list saved searches (see my prot/rg-save-search-as-name in the package declaration below). Saved searches are regular buffers. You can switch to any of them the normal way.

While inside of an rg.el buffer, hit m to produce a transient menu from where you can refine your search. This works just like magit. In addition, you can consult the universal C-h m for documentation concerning the major mode you are in.

Concerning the key bindings for navigating the results buffer, I find that the standard motions should retain their general function, while moving between file headings can be done with M-{n,p}.

rg.el is designed in such a way that it offers useful functionality without depending on a particular completion framework (e.g. Ivy, Helm). I consider this an advantage, especially when combined with the overall alignment of this package with standard Emacs tools.

Also see my configurations for project-related commands.

(use-package rg
  :ensure t
  :after wgrep
  (setq rg-group-result t)
  (setq rg-hide-command t)
  (setq rg-show-columns nil)
  (setq rg-show-header t)
  (setq rg-custom-type-aliases nil)
  (setq rg-default-alias-fallback "all")

  (rg-define-search prot/grep-vc-or-dir
    :query ask
    :format regexp
    :files "everything"
    :dir (let ((vc (vc-root-dir)))
           (if vc
               vc                         ; search root project dir
             default-directory))          ; or from the current dir
    :confirm prefix
    :flags ("--hidden -g !.git"))

  (defun prot/rg-save-search-as-name ()
    "Save `rg' buffer, naming it after the current search query.

This function is meant to be mapped to a key in `rg-mode-map'."
    (let ((pattern (car rg-pattern-history)))
      (rg-save-search-as-name (concat "«" pattern "»"))))

  :bind (("M-s g" . prot/grep-vc-or-dir)
         :map rg-mode-map
         ("s" . prot/rg-save-search-as-name)
         ("C-n" . next-line)
         ("C-p" . previous-line)
         ("M-n" . rg-next-file)
         ("M-p" . rg-prev-file)))

4 Directory, buffer, window management

4.1 Dired (directory editor, file manager)

The directory editor abbreviated as "Dired" (which I pronounce like "tired", "mired", etc.) is a built-in tool that performs file management operations inside of an Emacs buffer. It is simply superb! I use it daily for a number of tasks.

You can interactively copy, move (rename), symlink, delete files and directories, handle permissions, compress or extract archives, run shell commands, combine Dired with regular editing capabilities as part of a keyboard macro, search[+replace] across multiple files, encrypt/decrypt files, and more. Combine that with the possibility of matching items with regular expressions or creating an editable Dired buffer and you have everything you need to maximise your productivity.

Check some of my videos:

4.1.1 Base settings for Dired

The options here are meant to do the following:

  • Copy and delete recursively. Do not ask about it.
  • Search only file names while point is there, else the rest (useful when using the detailed view).
  • Deletion sends items to the system's Trash, making it safer than the standard rm.
  • Prettify output. Sort directories first. Show dotfiles first. Omit implicit directories (the single and double dots). Use human-readable size units. There are also options for tweaking the behaviour of find-name-dired, in the same spirit. To learn everything about these switches, you need to read the manpage of ls. You can do it with M-x man RET ls.
  • Hide all the verbose details by default (permissions, size, etc.). These can easily be toggled on using the left parenthesis ( inside a dired buffer. Also enable highlighting of the current line, which makes it even easier to spot the current item (I do not enable this globally, because I only want it for per-line interfaces, such as Dired's, but not for per-character ones, such as text editing).
  • While having two dired buffers side-by-side, the rename and copy operations of one are easily propagated to the other. Dired is smart about your intentions and uses the adjacent Dired buffer's path as a prefix when performing such actions.
  • For Emacs 27.1, Dired can automatically create destination directories for its copy and remove operations. So you can, for example, rename file to /non-existent-path/file and you will get what you want right away.
  • For Emacs 27.1, renaming a file of a version-controlled repository (git) will be done using the appropriate VC mechanism.
  • Let the relevant find commands use case-insensitive names.
  • Enable asynchronous mode. This is subject to change, as I need to test it a bit more.

Note that dired-listing-switches and find-ls-option are configured to show hidden directories and files before their non-hidden counterparts. If you want to reverse this order, you must append the -X option (such as -AFXhlv --group-directories-first).

(use-package dired
  (setq dired-recursive-copies 'always)
  (setq dired-recursive-deletes 'always)
  (setq delete-by-moving-to-trash t)
  (setq dired-listing-switches "-AFhlv --group-directories-first")
  (setq dired-dwim-target t)
  :hook ((dired-mode . dired-hide-details-mode)
         (dired-mode . hl-line-mode)))

(use-package dired-aux
  (setq dired-isearch-filenames 'dwim)
  ;; The following variables were introduced in Emacs 27.1
  (setq dired-create-destination-dirs 'ask)
  (setq dired-vc-rename-file t)
  :bind (:map dired-mode-map
              ("C-c +" . dired-create-empty-file)
              ("M-s f" . nil)))

(use-package find-dired
  :after dired
  (setq find-ls-option
        '("-ls" . "-AFhlv --group-directories-first"))
  (setq find-name-arg "-iname"))

(use-package async
  :ensure t)

(use-package dired-async
  :after (dired async)
  :hook (dired-mode . dired-async-mode))

Pro tip while renaming or copying a file, M-n will return its original name, thus allowing you to easily {pre,ap}pend to it. This leverages an intriguing concept of Emacs' design called "future history" (because M-p goes back to your previous entries). The notion of the future history, when applied, is basically an educated guess of what the user would want to do in the current context, given that they are not searching through their previous actions.

4.1.2 Narrowed dired

The easiest way to produce a Dired buffer with only a handful of files is to mark them, either manually or with % m, then toggle the mark with t, and then remove (just from the view) everything with k. This will leave you with only the files you need to focus on.

For dynamic filtering, use this package. Exit the narrowed view with g (which is generally used to regenerate the listing).

The keys for this are meant to resemble other common search patterns such as occur. Other useful interactive functions I considered, but opted against them in the interest of simplicity:

  • dired-narrow-regexp
  • dired-narrow-fuzzy
(use-package dired-narrow
  :ensure t
  :after dired
  (setq dired-narrow-exit-when-one-left t)
  (setq dired-narrow-enable-blinking t)
  (setq dired-narrow-blink-time 0.3)
  :bind (:map dired-mode-map
         ("M-s n" . dired-narrow)))

4.1.3 wdired (writable dired)

This is the editable state of a dired buffer. You can access it with C-x C-q. Write changes to files or directories, as if it were a regular buffer, then confirm them with C-c C-c.

  • While in writable state, allow the changing of permissions.
  • While renaming a file, any forward slash is treated like a directory and is created directly upon successful exit.
(use-package wdired
  :after dired
  :commands wdired-change-to-wdired-mode
  (setq wdired-allow-to-change-permissions t)
  (setq wdired-create-parent-directories t))

4.1.4 peep-dired (file previews including images)

By default, dired does not show previews of files, while image-dired is intended for a different purpose. We just want to toggle the behaviour while inside a regular dired buffer.

(use-package peep-dired
  :ensure t
  :after dired
  (setq peep-dired-cleanup-on-disable t)
  (setq peep-dired-enable-on-directories nil)
  (setq peep-dired-ignored-extensions
        '("mkv" "webm" "mp4" "mp3" "ogg" "iso"))
  :bind (:map dired-mode-map
              ("P" . peep-dired)))

4.1.5 image-dired (image thumbnails and previews)

This tool offers facilities for generating thumbnails out of a selection of images and displaying them in a separate buffer. An external program is needed for converting the images into thumbnails: imagemagick. Other useful external packages are optipng and sxiv. The former is for operating on PNG files, while the latter is a lightweight image viewer.

I feel this process is a bit cumbersome and can be very slow if you try to generate lots of images at once. The culprit is the image converter.

(use-package image-dired
  (setq image-dired-external-viewer "xdg-open")
  (setq image-dired-thumb-size 80)
  (setq image-dired-thumb-margin 2)
  (setq image-dired-thumb-relief 0)
  (setq image-dired-thumbs-per-row 4)
  :bind (:map image-dired-thumbnail-mode-map
              ("<return>" . image-dired-thumbnail-display-external)))

4.1.6 dired-subtree (tree-style view/navigation)

Tree-style navigation means that the subdirectories of the current Dired buffer can be expanded and contracted in place. It then is possible to perform the same kind of folding on their subdirectories, and so on.

This is, in my opinion, a far more intuitive interaction than the default way of inserting subdirectories in the current buffer below their parent (type i over the target dir). There still are uses for that technique, but tree-style navigation is easier for day-to-day tasks.

What I have here:

  • The tab key will expand or contract the subdirectory at point.
  • C-TAB will behave just like org-mode handles its headings: hit it once to expand a subdir at point, twice to do it recursively, thrice to contract the tree.
  • I also have Shift-TAB for contracting the subtree when the point is inside of it.
(use-package dired-subtree
  :ensure t
  :after dired
  (setq dired-subtree-use-backgrounds nil)
  :bind (:map dired-mode-map
              ("<tab>" . dired-subtree-toggle)
              ("<C-tab>" . dired-subtree-cycle)
              ("<S-iso-lefttab>" . dired-subtree-remove)))

4.1.7 dired-x (extra Dired functions)

These are some additional features that are shipped with Emacs. The one I need the most is dired-jump and its "other window" variant. These are among my favourite commands. They will always take you to the directory that contains the current buffer.

'Jumping' works even when you are inside buffers that do not visit files, such as Magit. Edit a file then proceed to do some file management, then invoke previous-buffer or winner-undo to go back to where you were (I have a key bindings for those in the Window configuration section). Everything happens naturally. Emacs' interconnectedness at its best!

I keep dired-clean-confirm-killing-deleted-buffers to t as a safety mechanism: if a file is ever deleted by accident I can use its buffer to restore it (never happened in practice).

With regard to binding keys, I choose to handle things myself. There has never been a case where I had to run info or man inside of a directory listing and wished there was some keyboard shortcut readily available.

While in dired-mode, if you need to open all marked files at once, you can hit F. It calls dired-do-find-marked-files.

As for my two functions, they leverage a command found in this library. I call them with M-x as their utility is very specialised.

(use-package dired-x
  :after dired
  (setq dired-clean-up-buffers-too t)
  (setq dired-clean-confirm-killing-deleted-buffers t)
  (setq dired-x-hands-off-my-keys t)
  (setq dired-bind-man nil)
  (setq dired-bind-info nil)

  (defun prot/kill-current-filename ()
    "Place the current buffer's file name in the `kill-ring'."
    (kill-new (dired-filename-at-point)))

  (defun prot/insert-current-filename ()
    "Insert at point the current buffer's file name."
    (insert (dired-filename-at-point)))

  :bind (("C-x C-j" . dired-jump)
         ("s-j" . dired-jump)
         ("C-x 4 C-j" . dired-jump-other-window)
         ("s-J" . dired-jump-other-window)))

4.1.8 dired-rsync

The rsync utility is great for performing file transfers between different systems (such as via SSH). I have been using the standard CLI tool for quite some time now. This package offers integration with Dired (do M-x man rsync RET and read this package's README for more information on the technicalities).

(use-package dired-rsync
  :ensure t
  :bind (:map dired-mode-map
              ("r" . dired-rsync)))

4.1.9 diredfl (more dired colours)

This package defines a few more colours for Dired, especially while in the detailed view. My themes support it, as well as a ton of other packages (see the section on my Modus themes).

(use-package diredfl
  :ensure t
  :hook (dired-mode . diredfl-mode))

4.1.10 Git overview in Dired

I generally do not need to have the git related information readily available. I use a dedicated package for version control. Still, there are cases where just toggling on an overview is all you ever need.

The commit message format is configured to show an abbreviated hash of the commit, the commit subject, and the relative date. The \t represents the tab character and is there to ensure alignment.

(use-package dired-git-info
  :ensure t
  :after dired
  (setq dgi-commit-message-format "%h\t%s\t%cr")
  :bind (:map dired-mode-map
              (")" . dired-git-info-mode)))

4.2 Working with buffers

4.2.1 Unique names for buffers

These settings make it easier to work with multiple buffers. When two buffers have the same name, Emacs will try to disambiguate them by displaying their unique path inside angled brackets. With the addition of uniquify-strip-common-suffix it will also remove the part of the file system path they have in common.

All such operations are reversed once an offending buffer is removed from the list, allowing Emacs to revert to the standard of displaying only the buffer's name.

(use-package uniquify
  (setq uniquify-buffer-name-style 'post-forward-angle-brackets)
  (setq uniquify-strip-common-suffix t)
  (setq uniquify-after-kill-buffer-p t))

4.2.2 Configure ibuffer

ibuffer is a built-in replacement for buffer-list that allows for fine-grained control over the buffer list (both work similar to dired).

Some tweaks to the default behaviour and presentation:

  • Prompt for confirmation only when deleting a modified buffer.
  • Hide the summary.
  • Do not open on the other window (not focused window).
  • Do not show empty filter groups.
  • Do not cycle movements. So do not go to the top when moving downward at the last item on the list.
  • Use colours for common actions more consistently. Inherit styles from Dired (see my Modus themes).
  • Remap default key to launch ibuffer instead of list-buffers.
(use-package ibuffer
  (setq ibuffer-expert t)
  (setq ibuffer-display-summary nil)
  (setq ibuffer-use-other-window nil)
  (setq ibuffer-show-empty-filter-groups nil)
  (setq ibuffer-movement-cycle nil)
  (setq ibuffer-default-sorting-mode 'filename/process)
  ;;;; NOTE built into the Modus themes
  ;; (setq ibuffer-deletion-face 'dired-flagged)
  ;; (setq ibuffer-marked-face 'dired-marked)
  (setq ibuffer-title-face 'font-lock-doc-face)
  (setq ibuffer-use-header-line t)
  (setq ibuffer-default-shrink-to-minimum-size nil)
  (setq ibuffer-formats
        '((mark modified read-only locked " "
                (name 30 30 :left :elide)
                " "
                (size 9 -1 :right)
                " "
                (mode 16 16 :left :elide)
                " " filename-and-process)
          (mark " "
                (name 16 -1)
                " " filename)))
  (setq ibuffer-saved-filter-groups
           ("Directories" (mode . dired-mode))
           ("Org" (mode . org-mode))
           ("Programming" (or
                           (mode . c-mode)
                           (mode . conf-mode)
                           (mode . css-mode)
                           (mode . emacs-lisp-mode)
                           (mode . html-mode)
                           (mode . mhtml-mode)
                           (mode . python-mode)
                           (mode . ruby-mode)
                           (mode . scss-mode)
                           (mode . shell-script-mode)
                           (mode . yaml-mode)))
           ("Markdown" (mode . markdown-mode))
           ("Magit" (or
                     (mode . magit-blame-mode)
                     (mode . magit-cherry-mode)
                     (mode . magit-diff-mode)
                     (mode . magit-log-mode)
                     (mode . magit-process-mode)
                     (mode . magit-status-mode)))
           ("Apps" (or
                    (mode . bongo-playlist-mode)
                    (mode . elfeed-search-mode)
                    (mode . elfeed-show-mode)))
           ("Gnus" (or
                    (mode . message-mode)
                    (mode . mail-mode)
                    (mode . gnus-article-mode)
                    (mode . gnus-group-mode)
                    (mode . gnus-server-mode)
                    (mode . gnus-summary-mode)))
           ("Emacs" (or
                     (name . "^\\*Help\\*$")
                     (name . "^\\*Custom.*")
                     (name . "^\\*Org Agenda\\*$")
                     (name . "^\\*info\\*$")
                     (name . "^\\*scratch\\*$")
                     (name . "^\\*Backtrace\\*$")
                     (name . "^\\*Messages\\*$"))))))
  (ibuffer-mode . hl-line-mode)
  (ibuffer-mode . (lambda ()
                    (ibuffer-switch-to-saved-filter-groups "Main")))
  :bind (("C-x C-b" . ibuffer)))

4.3 Window configuration

I believe that Emacs' true power lies in its buffer management rather than its multiplexing. The latter becomes inefficient at scale, since it tries to emulate the limitations of the real world, namely, the placement of things on a desk.

By leveraging the power of the computer, we can use search methods to easily reach any item. There is no need to remain confined to the idea of a finite space (screen real estate) that needs to be carefully managed.

That granted, Emacs' multiplexing can be turned into a powerhouse as well, covering everything from window placement rules, to the recording of history and layouts, as well as directional or direct window navigation.

4.3.1 Window rules and basic tweaks

The display-buffer-alist and all other functions grouped together with prot/window-dired-vc-root-left are considered experimental and subject to review. The former is intended as a rule-set for controlling the display of windows. While the latter serves as a series of tangible examples of passing certain rules programmatically, in combination with a few relevant extras. The objective is to create a more intuitive workflow where targeted buffer groups or types are always shown in a given location, on the premise that predictability improves usability.

For each buffer action in display-buffer-alist we can define several functions for selecting the appropriate window. These are executed in sequence, but my usage thus far suggests that a simpler method is just as effective for my case.

Everything pertaining to buffer actions is documented at length in the GNU Emacs Lisp Reference Manual, currently corresponding to version 26.3. Information can also be found via C-h f display-buffer and, for my settings, C-h f display-buffer-in-side-window.

With regard to the contents of the :bind keyword of the window library, most key combinations are complementary to the standard ones, such as C-x 1 becoming s-1, C-x o turning into s-o and the like. They do not replace the defaults: they just provide more convenient access to their corresponding functions. They all involve the Super key, following the norms described in the introductory note on the matter. Concerning the balance-windows-area I find that it is less intrusive than the original balance-windows normally bound to the same C-x +.

For a demo of the display-buffer-alist and the functions that accompany it, watch my video on rules for buffer placement (2020-01-07).

(use-package window
  (setq display-buffer-alist
        '(;; top side window
           (window-height . 0.16)
           (side . top)
           (slot . 0)
           (window-parameters . ((no-other-window . t))))
           (window-height . 0.16)
           (side . top)
           (slot . 1)
           (window-parameters . ((no-other-window . t))))
          ;; bottom side window
          ("\\*\\(Output\\|Register Preview\\).*"
           (window-width . 0.16)       ; See the :hook
           (side . bottom)
           (slot . -1)
           (window-parameters . ((no-other-window . t))))
           (window-height . 0.16)
           (side . bottom)
           (slot . 0)
           (window-parameters . ((no-other-window . t))))
           (window-height . 0.16)
           (side . bottom)
           (slot . 1))
          ;; left side window
           (window-width . 0.20)       ; See the :hook
           (side . left)
           (slot . 0)
           (window-parameters . ((no-other-window . t))))
          ;; right side window
           (window-width . 0.25)
           (side . right)
           (slot . 0)
           (window-parameters . ((no-other-window . t)
                                 (mode-line-format . (" "
           (window-width . 0.25)
           (side . right)
           (slot . 1))))
  (setq window-combination-resize t)
  (setq even-window-sizes 'height-only)
  (setq window-sides-vertical nil)
  :hook ((help-mode . visual-line-mode)
         (custom-mode . visual-line-mode))
  :bind (("s-n" . next-buffer)
         ("s-p" . previous-buffer)
         ("s-o" . other-window)
         ("s-2" . split-window-below)
         ("s-3" . split-window-right)
         ("s-0" . delete-window)
         ("s-1" . delete-other-windows)
         ("s-5" . delete-frame)
         ("C-x +" . balance-windows-area)
         ("<f8>" . window-toggle-side-windows)))

;; These are all experimental.  Just showcasing the power of passing
;; parameters to windows or frames.
(use-package emacs
  (defun prot/window-dired-vc-root-left ()
    "Open root directory of current version-controlled repository
or the present working directory with `dired' and bespoke window
parameters.  This is meant as a proof-of-concept function,
illustrating how to leverage window rules to display a buffer,
plus a few concomitant extras."
    (let ((dir (if (eq (vc-root-dir) nil)
                   (dired-noselect default-directory)
                 (dired-noselect (vc-root-dir)))))
       dir `((side . left)
             (slot . -1)
             (window-width . 0.16)
             (window-parameters . ((no-other-window . t)
                                   (no-delete-other-windows . t)
                                   (mode-line-format . (" "
      (with-current-buffer dir
        (rename-buffer "*Dired-Side*")
        (setq-local window-size-fixed 'width)))
    (with-eval-after-load 'ace-window
      (when (boundp 'aw-ignored-buffers)
        (add-to-list 'aw-ignored-buffers "*Dired-Side*"))))

  (defun prot/make-frame-floating-with-current-buffer ()
    "Display the current buffer in a new floating frame.

This passes certain parameters to the newly created frame:

- use a different name than the default;
- use a graphical frame;
- do not display the minibuffer.

The name is meant to be used by the external rules of my tiling
window manager (BSPWM) to present the frame in a floating state."
    (make-frame '((name . "my_float_window")
                  (window-system . x)
                  (minibuffer . nil))))

  (defun prot/display-buffer-at-bottom ()
    "Move the current buffer to the bottom of the frame.  This is
useful to take a buffer out of a side window.

The window parameters of this function are provided mostly for
didactic purposes."
    (let ((buffer (current-buffer)))
      (with-current-buffer buffer
         buffer `((window-parameters . ((mode-line-format . (" "
  :bind (("C-c d" . prot/window-dired-vc-root-left)
         ("C-c f" . prot/make-frame-floating-with-current-buffer)
         ("C-c b" . prot/display-buffer-at-bottom)))

4.3.2 Window history and directional motions (winner-mode and windmove)

Winner is a built-in tool that keeps a record of buffer and window layout changes. It then allows us to move back and forth in the history of said changes. I have it enabled by default, while I assign its two main functions to Super and the right/left arrow keys.

(use-package winner
  :hook (after-init . winner-mode)
  :bind (("<s-right>" . winner-redo)
         ("<s-left>" . winner-undo)))

Windmove is also built into Emacs. It provides functions for selecting a window in any of the cardinal directions. I use the Vim keys while holding down Super and Meta because other mnemonics-based actions involving just Super or Meta are already occupied.

The windmove-create-window specifies what should happen when trying to move past the edge of the frame. The idea with this is to allow it to create a new window. I do not want that.

(use-package windmove
  (setq windmove-create-window nil)     ; Emacs 27.1
  :bind (("M-s-h" . windmove-left))
         ("M-s-j" . windmove-down)
         ("M-s-k" . windmove-up)
         ("M-s-l" . windmove-right))

4.3.3 ace-window (more flexible window motions)

With ace-window (from the developer of Ivy/Counsel/Swiper…) we can both enhance the movement between windows, but also perform additional actions to them. These are listed in aw-dispatch-list. Note that the keys in that list must not conflict with those in aw-keys.

Make sure to also refer to the previous sections on:

(use-package ace-window
  :ensure t
  (setq aw-keys '(?h ?j ?k ?l ?y ?u ?i ?o ?p))
  (setq aw-scope 'frame)
  (setq aw-dispatch-always t)
  (setq aw-dispatch-alist
        '((?s aw-swap-window "Swap Windows")
          (?2 aw-split-window-vert "Split Window Vertically")
          (?3 aw-split-window-horz "Split Window Horizontally")
          (?? aw-show-dispatch-help)))
  (setq aw-minibuffer-flag t)
  (setq aw-ignore-current nil)
  (setq aw-display-mode-overlay t)
  (setq aw-background t)

  (ace-window-display-mode -1)
  :bind (("s-a" . ace-window)))

5 Applications and utilities

This section includes configurations for programs like email clients, news reader, music players… Anything you would normally see in a standalone application. The end goal is to eventually integrate every aspect of my computing inside of Emacs.

5.1 Calendar


Some basic settings for this tool. It is used by the diary (next section), as well as all Org-mode facilities that require date/time input (see following sections).

(use-package calendar
  (setq calendar-mark-diary-entries-flag t)
  (setq calendar-time-display-form
        '(24-hours ":" minutes
                   (when time-zone
                     (concat " (" time-zone ")"))))
  (setq calendar-week-start-day 1)      ; Monday
  (setq calendar-date-style 'iso)
  (setq calendar-holidays
        (append holiday-general-holidays holiday-local-holidays
                holiday-other-holidays holiday-christian-holidays
                holiday-islamic-holidays holiday-oriental-holidays
  :hook (calendar-today-visible . calendar-mark-today))

5.2 Diary


Emacs comes with a built-in facility to record tasks and create notifications for them. It is simply called diary. I am still assessing its overall utility in my workflow.

(use-package diary-lib
  (setq diary-file "~/.emacs.d/diary")
  (setq diary-entry-marker "diary")
  (setq diary-show-holidays-flag t)
  (setq diary-header-line-flag nil)
  (setq diary-mail-addr "public@protesilaos.com")
  (setq diary-mail-days 3)
  (setq diary-number-of-entries 3)
  (setq diary-comment-start ";")
  (setq diary-comment-end "")
  (setq diary-date-forms
        '((day "/" month "[^/0-9]")
          (day "/" month "/" year "[^0-9]")
          (day " *" monthname " *" year "[^0-9]")
          (monthname " *" day "[^,0-9]")
          (monthname " *" day ", *" year "[^0-9]")
          (year "[-/]" month "[-/]" day "[^0-9]")
          (dayname "\\W"))))

5.3 Org-mode (personal information manager)

Org offers you the basic tools to organise your life in super-efficient ways using nothing but plain text.

In its purest form, Org is a markup language that is similar to Markdown: symbols are used to denote the meaning of a construct in its context, such as what may represent a headline element or a phrase that calls for emphasis.

What lends Org its super powers though is everything else built around it: a rich corpus of elisp functions that automate, link, combine, enhance, structure, or otherwise enrich the process of using this otherwise simple markup language. This very document is written in org-mode while its website version is produced by a function that exports Org notation into its HTML equivalent.

This section contains several sub-sections, each dedicated to a particular aspect of Org. Unless otherwise specified, everything is a work-in-progress as I gradually build up my knowledge of this killer app.

5.3.1 Org basic configurations

These are the base settings that other more specialised functions of Org depend on. Here is an overview:

Agenda and default setup
The bulk of the org-agenda configurations is defined in a subsequent section. Here we just declare the default file system paths for searching for relevant files. The "notes" file is meant as a fallback option for when org-capture has not been given a file to write at (also see the org-capture section).
Re-filing items
This is done with C-c C-w which then prompts us for a heading under which the current item should be positioned. I set my Org agenda files as one possible target and the current buffer as the other. The maximum depth should be 2 levels. Re-filing can also be done from inside an org-capture interface. Any new entry should go at the end of the heading it is filled under.
To-do settings
I generally use a very simple system of writing tasks, in the sense that I do not really care about time-tracking or assigning an intermediate state, etc. I let tags and the description further qualify the meaning. The letter inside parentheses is for faster access when using the C-c C-t method. The upside of having lots of specialised keywords is that it becomes easier to filter your tasks in the relevant agenda views.
Logging meta data
I do not really care about tracking all the minutia of why a deadline was reviewed or whatnot. Though it is kind of nice to have a timestamp of when a task was concluded (still don't care about it).

Now on to the miscellaneous settings:

  • With the t value of org-special-ctrl-a/e we assign a special meaning to the motions that take us to the beginning or end of the line when those are performed over a heading. The idea here is that we can always perform changes to the absolute beginning of the line, such as by increasing the heading's depth with M-right.
  • I do not enable this sort of contextual awareness for the C-k command, because I do consider it rather unpredictable.
  • All the markup characters should be hidden from view, in the same way links are. This generally reduces the distractions in the document.
  • The org-structure-template-alist had its value and functionality changed in Org version 9.2, which ships with Emacs 27. To insert a template you must now use C-c C-,.
  • The return key should never follow a link because I sometimes call it by accident. Use C-c C-o instead.
  • The org-store-link is one of the nicest additions. Use it to store a direct link to the heading at point. Then invoke C-c C-l with or without an active region, to create a link to that location (when the region is active, its text will be used for the link, subject to confirmation and further editing). This is how I create the various internal links that point to other parts of this document.
  • With org-loop-over-headlines-in-active-region we can perform actions such as tagging and scheduling on the items within the active region. I configure it to only apply to headings of the same level, in order to avoid possible inconveniences.

2020-02-07: WORK IN PROGRESS

(use-package org
  ;; agenda and basic directory structure
  (setq org-directory "~/Org")
  (setq org-default-notes-file "~/Org/notes.org")
  (setq org-agenda-files
  (setq org-deadline-warning-days 3)
  ;; refile, todo
  (setq org-refile-targets
        '((org-agenda-files . (:maxlevel . 2))
          (nil . (:maxlevel . 2))))
  (setq org-refile-use-outline-path t)
  (setq org-refile-allow-creating-parent-nodes 'confirm)
  (setq org-refile-use-cache t)
  (setq org-reverse-note-order nil)
  (setq org-todo-keywords
        '((sequence "TODO(t)" "|" "DONE(D)" "CANCELLED(C)")
          (sequence "ACT(a)" "|" "ACTED(A)")
          (sequence "BUY(b)" "|" "BOUGHT(B)")
          (sequence "MEET(m)" "|" "MET(M)" "POSTPONED(P)")
          (sequence "STUDY(s)" "|" "STUDIED(S)")
          (sequence "RECORD(r)" "|" "RECORDED(R)")))
  (setq org-fontify-done-headline t)
  (setq org-enforce-todo-dependencies t)
  (setq org-enforce-todo-checkbox-dependencies t)
  (setq org-track-ordered-property-with-tag t)
  (setq org-highest-priority ?A)
  (setq org-lowest-priority ?C)
  (setq org-default-priority ?A)
  ;; code blocks
  (setq org-confirm-babel-evaluate nil)
  ;; log
  (setq org-log-done 'time)
  (setq org-log-note-clock-out nil)
  (setq org-log-redeadline nil)
  (setq org-log-reschedule nil)
  (setq org-read-date-prefer-future 'time)
  ;; general
  (setq org-special-ctrl-a/e t)
  (setq org-special-ctrl-k nil)
  (setq org-hide-emphasis-markers t)
  (setq org-structure-template-alist    ; CHANGED in Org 9.2, Emacs 27.1
        '(("s" . "src")
          ("E" . "src emacs-lisp")
          ("e" . "example")
          ("q" . "quote")
          ("v" . "verse")
          ("V" . "verbatim")
          ("c" . "center")
          ("C" . "comment")))
  (setq org-catch-invisible-edits 'show)
  (setq org-return-follows-link nil)
  (setq org-loop-over-headlines-in-active-region 'start-level)
  :bind (("C-c l" . org-store-link)
         :map org-mode-map
         ("<C-return>" . nil)
         ("<C-S-return>" . nil)))

5.3.2 Org-capture templates

The org-capture tool is a powerful way to quickly produce some kind of structured information. The type of data and the way to store is determined by a system of templates which accepts a series of possible specifiers as well as the evaluated part of arbitrary elisp code.

Each template is accessed via a key. These are listed in a buffer when you call org-capture. Unique keys give direct access to their template, whereas templates that share a common initial key will produce a second selection list with the remaining options. In the latter case, the initial key entry has no call to an actual function, but is just written as a heading. For an example, look how I do the "contact information": all templates whose keys follow the pattern cX are only visible after hitting c and are then accessed via X.

The visibility of a template is further controlled by another variable: org-capture-templates-contexts. This allows us to tell Org the context in which we want certain options to appear in. Otherwise they remain concealed from our view. Equipped with this piece of functionality, we can freely write highly-specialised templates that capture structured text when viewing some particular item, but are not needed for more general purposes. I do this for certain actions that only come into effect when reading email inside of the relevant gnus buffers (also check my comprehensive configurations for email and the Gnus news/mail reader).

Speaking of mail, you will notice some specifiers like :fromname. This refers to the From field in emails and will capture the name part only. Other similar keywords are :from (name and email), :fromaddress (email only), :subject.

Specifiers that start with the caret sign (^) represent prompts for further user input. The pattern ^{TEXT} is a prompt whose name is TEXT. To offer possible options, use ^{Initial|ONE|TWO|THREE}, where the first entry is the text of the prompt and all the rest are the available choices. In some templates I use the ^t specifier, which is a built-in method to ask for a specific date.

The text that goes into a template can be written as part of a string or inside a function that is then evaluated. I generally prefer to use simple strings, though I might revise this approach going forward. To insert a new line inside of a string, use \n.

The %? determines where the point should be once the template is filled in. While %i will insert the contents of the active region.

As things currently stand, my capture templates always write to headings inside of files. Note though that there are more possibilities, as described in the manual.

A file can be specified by its absolute path or just a name. In the latter case, its location is understood relative to org-directory. When using the file+headline pattern, non-existing files are created automatically once you call the relevant template. Same for their respective headings.

Finally, the contrib/org-capture-no-delete-windows and relevant advice address a problem I have when org-capture fails to conclude its actions when called from inside of a side window (for more on those, refer to the section on Window rules and basic tweaks). The code is taken directly from this Stack Overflow thread.

(use-package org-capture
  :after org
  (setq org-capture-templates
        '(("b" "Basic task" entry
           (file+headline "tasks.org" "Basic tasks that need to be reviewed")
           "* %?")
          ("c" "Capture some concise actionable item and exit immediately" entry
           (file+headline "tasks.org" "Task list without a defined date")
           "* TODO [#B] %^{Title}\n :PROPERTIES:\n :CAPTURED: %U\n :END:\n\n %i %l" :immediate-finish t)
          ("t" "Task of importance with a tag, deadline, and further editable space" entry
           (file+headline "tasks.org" "Task list with a date")
           "* %^{Scope of task||TODO [#A]|STUDY [#A]|MEET with} %^{Title} %^g\n DEADLINE: %^t\n :PROPERTIES:\n :CONTEXT: %a\n:CAPTURED: %U\n :END:\n\n %i %?")
          ("r" "Reply to an email" entry
           (file+headline "tasks.org" "Mail correspondence")
           "* TODO [#B] %:subject\n SCHEDULED: %t\n :PROPERTIES:\n :CONTEXT: %a\n :END:\n\n %i %?")
          ("i" "Idea")
          ("ia" "Activity or event" entry
           (file+headline "ideas.org" "Activities or events")
           "* ACT %^{Act about what}%? :private:\n :PROPERTIES:\n :CAPTURED: %U\n :END:\n\n %i")
          ("ie" "Essay or publication" entry
           (file+headline "ideas.org" "Essays or publications")
           "* STUDY %^{Expound on which thesis}%? :private:\n :PROPERTIES:\n :CAPTURED: %U\n :END:\n\n %i")
          ("iv" "Video blog or screen cast" entry
           (file+headline "ideas.org" "Screen casts or vlogs")
           "* RECORD %^{Record on what topic}%? :private:\n :PROPERTIES:\n :CAPTURED: %U\n :END:\n\n %i")))
  (setq org-capture-templates-contexts
        '(("r" ((in-mode . "gnus-article-mode")
                (in-mode . "gnus-summary-mode")))))

  (defun contrib/org-capture-no-delete-windows (oldfun args)
    (cl-letf (((symbol-function 'delete-other-windows) 'ignore))
      (apply oldfun args)))

  (with-eval-after-load "org-capture"
    (advice-add 'org-capture-place-template :around 'contrib/org-capture-no-delete-windows))

  :bind ("C-c c" . org-capture))

5.3.3 Org agenda

The org-agenda is not just a single interface. It rather is your conduit to a set of utilities from where you can keep track of all the tasks you have written in the files declared as part of org-agenda-files (see its value in the section that covers the base Org configurations). Invoking org-agenda will present you with a list of possible options. Here is a primer (there are many more functions documented in the manual):

  • The a is where you keep track of all the items that have a date assigned to them, be it SCHEDULED or DEADLINE. To assign such a value to a heading use C-c C-s or C-c C-d respectively.
  • The t will list all your tasks, regardless of whether they have a date assigned to them. You can then filter by keyword, regular expression, etc.
  • And the n will offer you a combined view of the above.

Now a few words about some of my customisations (remember to use Emacs' documentation facilities over each item, such as C-h v):

  • Always ask for confirmation when hitting C-k from the agenda views. That command removes the entry in the original file.
  • I do not use the built-in diary and am generally not interested in meticulous time tracking, the 'special' day of X, etc. It is the kind of busywork that has no place in my simple, as-stress-free-as-possible life. The Org manual suggests that we can use the diary functionality to “keep track of anniversaries, lunar phases, sunrise/set”. Sure…
  • Show all dates in the current view, including those that have no entries. I find it easier that way to assess how far apart the tasks are.
  • Do not produce a message in the echo area showing the outline path. It is too distracting.
  • Any valid time expressions in headlines should be ignored. Otherwise they are used as part of the relevant sorting methods.
  • The default view should just show me a three day span. All the commands for changing views still work as expected (e.g. hit w to show the current week).
  • Disable follow mode by default. This produces a view of the current item's original context in the other window. It can be toggled on by hitting F.
  • Time stamps should always be expressed in 24h format.
  • Make minor tweaks to the time grid view format.
  • Disable the key bindings that cycle through the agenda files: too easy to hit while trying to perform some other action. Besides, I do not need that kind of functionality.
(use-package org-agenda
  :after org
  (setq org-agenda-confirm-kill t)
  (setq org-agenda-dim-blocked-tasks t)
  (setq org-agenda-include-diary nil)
  (setq org-agenda-show-all-dates t)
  (setq org-agenda-show-outline-path nil)

  ;; All the "skip" need to be reviewed
  (setq org-agenda-skip-additional-timestamps-same-entry t)
  (setq org-agenda-skip-deadline-prewarning-if-scheduled t)
  (setq org-agenda-skip-scheduled-delay-if-deadline t)
  (setq org-agenda-skip-scheduled-if-deadline-is-shown t)
  (setq org-agenda-skip-scheduled-if-done t)
  (setq org-agenda-skip-timestamp-if-deadline-is-shown t)
  (setq org-agenda-skip-timestamp-if-done t)

  (setq org-agenda-search-headline-for-time nil)
  (setq org-agenda-span 3)
  (setq org-agenda-start-on-weekday 1)  ; Monday
  (setq org-agenda-start-with-follow-mode nil)
  (setq org-agenda-timegrid-use-ampm nil)
  (setq org-agenda-time-grid
        '((daily today require-timed)
          (0800 1000 1200 1400 1600 1800 2000)
          "      " "················"))
  (setq org-agenda-use-time-grid t)
  (setq org-agenda-window-setup 'current-window)
  (setq org-agenda-todo-list-sublevels t)
  :bind (("C-c a" . org-agenda)
         :map org-mode-map
         ("C-'" . nil)
         ("C-," . nil)))

5.3.4 Org source code blocks

These are just some basic settings that are particularly useful when inserting source code blocks. I do not want Org to mess up with my indentation, while I need to see the native syntax highlighting for that language.

The org-src-window-setup is accessed via the C-c ' key once inside a code block that has a language assigned to it.

(use-package org-src
  :after org
  (setq org-src-window-setup 'current-window)
  (setq org-src-fontify-natively t)
  (setq org-src-preserve-indentation t)
  (setq org-src-tab-acts-natively t)
  (setq org-edit-src-content-indentation 0))

5.3.5 Org export

Org's "export" facility has the power to convert a .org file into a number of common formats, including .pdf. I only ever use it to produce the HTML version of this document or similar tasks along those lines. In the future, I might spend some time leveraging its potential for more demanding workflows.

(use-package ox
  :after org
  (setq org-export-with-toc t)
  (setq org-export-headline-levels 8)
  (setq org-export-backends
        '(ascii html latex md))
  (setq org-export-dispatch-use-expert-ui nil)) TODO review Org's exporting facilities [0/2]   emacs org TODO research derived export backends TODO automate webpage creation for dotemacs

5.3.6 Inherit theme styles in Org HTML export

With this package, every exported HTML code will inherit the styles of the current theme. This makes it particularly useful for highlighting blocks of source code.

(use-package htmlize
  :ensure t
  :after org
  (setq htmlize-ignore-face-size t))

5.3.7 Consistent heading IDs (and anchor tags)

Everything in this section is copied directly from this detailed tutorial on Org header IDs. Basically, the problem is that exported HTML does not have reliable anchor tags for the various sections of the document. This fixes the issue (read the article for more).

(use-package org-id
  :after org
  :commands (contrib/org-get-id
  (setq org-id-link-to-org-use-id 'create-if-interactive-and-no-custom-id)

  (defun contrib/org-get-id (&optional pom create prefix)
    "Get the CUSTOM_ID property of the entry at point-or-marker
POM. If POM is nil, refer to the entry at point. If the entry
does not have an CUSTOM_ID, the function returns nil. However,
when CREATE is non nil, create a CUSTOM_ID if none is present
already. PREFIX will be passed through to `org-id-new'. In any
case, the CUSTOM_ID of the entry is returned."
    (org-with-point-at pom
      (let ((id (org-entry-get nil "CUSTOM_ID")))
         ((and id (stringp id) (string-match "\\S-" id))
          (setq id (org-id-new (concat prefix "h")))
          (org-entry-put pom "CUSTOM_ID" id)
          (org-id-add-location id (buffer-file-name (buffer-base-buffer)))

  (defun contrib/org-id-headlines ()
    "Add CUSTOM_ID properties to all headlines in the current
file which do not already have one."
    (org-map-entries (lambda ()
                       (contrib/org-get-id (point) 'create)))))

5.3.8 Simple presentations inside of Emacs (org-tree-slide)

I like the idea of easily converting an .org file into a set of pseudo slides. It is simple and has no external dependencies. My needs are pretty simple and straightforward: just show some text, narrowing it to the current section.

To make presentations happen, I use org-tree-slide to narrow the buffer to each heading. The darkroom package centres the view, while removing the mode line. While org-superstar prettifies the heading bullets, while removing the leading stars. The other tweaks in the code block below are complementary to this "slideshow effect".

For the font specified herein, make sure to understand the overall configurations by reading the section on primary font settings. I opted not to use text-scale-adjust or some variant thereof, because that only operates on the text of the focused window, whereas I want all interfaces to adapt to the new size so that I can, for example, show the minibuffer while doing a presentation.

(use-package darkroom
  :ensure t
  (setq darkroom-text-scale-increase 0))

(use-package org-superstar              ; supersedes `org-bullets'
  :ensure t
  :after org
  (setq org-superstar-remove-leading-stars t))

(use-package org-tree-slide
  :ensure t
  :after (org darkroom)
  (setq org-tree-slide-breadcrumbs nil)
  (setq org-tree-slide-header nil)
  (setq org-tree-slide-slide-in-effect nil)
  (setq org-tree-slide-heading-emphasis nil)
  (setq org-tree-slide-cursor-init t)
  (setq org-tree-slide-modeline-display nil)
  (setq org-tree-slide-skip-done nil)
  (setq org-tree-slide-skip-comments t)
  (setq org-tree-slide-fold-subtrees-skipped t)
  (setq org-tree-slide-skip-outline-level 8)
  (setq org-tree-slide-never-touch-face t)

  (defun prot/org-presentation ()
    "Specifies conditions that should apply locally upon
activation of `org-tree-slide-mode'."
    (if (eq darkroom-tentative-mode nil)
          (darkroom-tentative-mode 1)
          (org-superstar-mode 1)
          (org-indent-mode 1)
          (blink-cursor-mode -1)
          (setq-local cursor-type '(bar . 1))
      (darkroom-tentative-mode -1)
      (org-superstar-mode -1)
      (org-indent-mode -1)
      (blink-cursor-mode 1)
      (setq-local cursor-type 'box)

  :bind (("<f9>" . org-tree-slide-mode)
         :map org-tree-slide-mode-map
         ("<C-right>" . org-tree-slide-move-next-tree)
         ("<C-left>" . org-tree-slide-move-previous-tree))
  :hook (org-tree-slide-mode . prot/org-presentation))

5.4 Email settings

Configuring email can be quite the challenge, largely because we have been used to the likes of Thunderbird, where you log in once and then everything "just works". The toolset for my current setup consists of the following:

  • Gnus (also pronounced as "News" or "Nooz", etc.), which is a powerful newsreader and email client that is built into Emacs.
  • The built-in capabilities to send email.

Previous versions of this document (prior to 2020-01-30) relied on external tools for fetching and reading email, in particular mu4e, the front-end to the mu mail indexer, and offlineimap. Whereas now I let Gnus handle the task of synchronising with the IMAP server and with all the news groups I am subscribed to. No need to worry about some complex mechanism for syncing, storing, indexing email.

Note that I do not work in an office context, do not need HTML in my email, and do not try to come up with some fancy mechanism for updating my sources and notifying me of the results. My approach is to update my sources manually: the idea is that if I have time to check my news, I also am able to act on them. If you have more complex needs, you will definitely need to adapt things accordingly. Still, this section contains lots of useful information to get you started.

5.4.1 Base email settings

Before configuring the email client, we need to establish the absolute essentials: who we are, where our credentials are stored, and whether encryption is supported. This is done in the first two package declarations.

Then we set up the interface for composing emails:

  • The mail-user-agent and message-mail-user-agent concern the default email composition buffer, called with C-x m or any other facility that falls back to the compose-mail function. The default is message-mode. When Gnus is running, it will insert relevant paraphernalia, the most important of which is the "Gcc" header. The Gcc saves a copy of the outgoing message to a specified group. In my case that is the "Sent" directory of my default IMAP account.
  • Function prot/message-header-add-gcc is directly related to the above. The inserted header points to my public email account, which is declared in user-mail-address. This concerns only the creation of new emails. While replying to a message, the appropriate information is filled in automatically, based on parameters I specify in the section about account settings and essential configurations.
  • The value of message-citation-line-format is expanded into something like "NAME <EMAIL> [2020-02-19 Wed]:". To learn about all the date-related specifiers, it is better for you to read the documentation with C-h v format-time-string.
(use-package auth-source
  (setq auth-sources '("~/.authinfo.gpg" "~/.authinfo"))
  (setq user-full-name "Protesilaos Stavrou")
  (setq user-mail-address "public@protesilaos.com"))

(use-package epa-file
  (setq epa-file-cache-passphrase-for-symmetric-encryption t))

(use-package message
  (setq mail-user-agent 'message-user-agent)
  (setq compose-mail-user-agent-warnings nil)
  (setq message-mail-user-agent nil)    ; default is `gnus'
  (setq mail-signature "Protesilaos Stavrou\nprotesilaos.com\n")
  (setq message-signature "Protesilaos Stavrou\nprotesilaos.com\n")
  (setq message-citation-line-format "%f [%Y-%m-%d, %R %z]:\n")
  (setq message-citation-line-function
  (setq message-confirm-send nil)
  (setq message-kill-buffer-on-exit t)
  (setq message-wide-reply-confirm-recipients t)
  (setq message-default-charset 'utf-8)
  (add-to-list 'mm-body-charset-encoding-alist '(utf-8 . base64))

  (defun prot/message-header-add-gcc ()
    "While `gnus' is running, add a Gcc header, if missing.

The Gcc header places a copy of the outgoing message to the
appropriate directory of the IMAP server, as per the contents of

In the absence of a Gcc header, the outgoing message will not
appear in the appropriate IMAP directory, though it will still be

Add this function to `message-header-setup-hook'."
    (if (gnus-alive-p)
          (when (message-fetch-field "Gcc")
            (message-remove-header "Gcc")
            (message-add-header "Gcc: nnimap+pub:Sent")))
      (message "Gnus is not running. No GCC field inserted.")))

  :hook ((message-header-setup . prot/message-header-add-gcc)
         (message-setup . message-sort-headers)))

Below is a sample with the contents of my authinfo.gpg. This is read by gnus and smtpmail to be able to both fetch and send messages from the given account. I strongly encourage you to encrypt this file if you add your login credentials there. Do it from inside dired with : e while the point is over the file. Emacs can decrypt all encrypted files automatically.

machine prv port 993 login MAIL password SECRET
machine inf port 993 login MAIL password SECRET
machine pub port 993 login MAIL password SECRET

machine mail.gandi.net port 465 login MAIL password SECRET
machine mail.gandi.net port 465 login MAIL password SECRET
machine mail.gandi.net port 465 login MAIL password SECRET

Refer to your email provider's documentation in order to determine the port number and server address you need to use for sending and receiving messages. The MAIL is either your email address or some username for logging into the account.

Note that the terms I use above for prv, inf, and pub are just arbitrary names for the given MAIL and SECRET combination. This allows us to reference each name in the Gnus configurations, and share those in a public document like this one, without worrying about leaking private data.

5.4.2 Gnus for reading email, mailing lists, and more

The documentation describes Gnus as the "coffee-brewing, all singing, all dancing, kitchen sink newsreader". I chuckled when I first read it, thinking to myself that the developers have an interesting sense of humour. Then I decided to quickly go through the list of user-facing customisation options: M-x customize-apropos-groups RET gnus RET … Not so funny after all!

Simply put, Gnus is massive. This makes it both extremely powerful and incredibly complicated for new users. Do not let that scare you though: start small and gradually tweak things as you go. This is how you approach Emacs itself. Learn the basics and then figure out your needs from then on.

Now some basic information on the abstractions that Gnus relies on:

  1. The default Gnus buffer is called "Group". It will present you with a list of all the news sources you have subscribed to. By default, Gnus only displays messages that have not been read. The same applies for groups. The "Group" buffer will be empty the very first time you log in because you have not subscribed to anything yet. Use g to fetch new messages from the sources. If you only want to refresh the group at point, do it with M-g.
  2. The "Server" buffer contains a list with all the sources you have specified for discovering news. In my case, these are my email accounts and a Usenet server where mailing lists are hosted. To access the "Server" buffer from inside the "Group" buffer, just hit the caret sign ^. To subscribe to an item, place the point over it and hit u. Do that for your email's inbox and for whatever mailing lists you intend to follow.
  3. The "Summary" buffer contains all the messages of a group. Hitting the return key over a message will split the view in two, with the list above and the message below. Use n or p to move to the next or previous unread message (or N and P to just the next/prev). You access the "Summary" buffer both from the "Group" and the "Server" by entering a group.

It is essential to take things slowly (and first test whether your messages are being sent and that you can receive them). Each buffer has some unique functions that are relevant to the current interface. To learn more about them, use C-h m. Do it for all three of the above. Also rely on C-h k to get information about what each key does in the given context (or just start a key sequence and then hit C-h to display possible combinations in a new Help buffer).

Now a couple more things about the "Group" buffer:

  • A group can be assigned a level of importance. This is a grade whose highest score is 1 and the lowest is 6 (customisable though). Each level has a different colour. To assign a new value to the group at point, do it with S l and then give it a number. Once you have graded your groups, you can perform various actions on a per-level basis. For example, to refresh all levels from 1 up to 3 but not higher, pass a numeric argument to the standard g command. So C-3 g (this is the same as C-u 3 g).
  • Groups can be organised by topic. Create a new one with T n and give it a name. Move a group to a topic with T m. To toggle the view of topics use t (I have a hook that does this automatically at startup). The level of indentation tells us whether a topic is a sub-set of another. Use TAB or C-u TAB to adjust it accordingly. As with levels, you can operate on a per-topic basis. For example, to catch up on all the news of a given topic (mark all as read), you place the point over it, hit c and then confirm your choice.

As noted, Gnus will only show you a list of unread items. To view all your groups, hit L. Use the lower case version l to view only the unread ones. To produce a Summary buffer with read items, hit C-u RET over a group and specify the number of messages you want to list (the other option is C-u M-g from inside the Summary). Another useful trick for the Summary buffer is the use of the caret sign (^) to show you the previous message that the current item is a reply to.

Consider watching my Introduction to Gnus (2020-02-02).

Notwithstanding the customisation options and various idiosyncratic design choices, some prior experience with Emacs' various interfaces will definitely come in handy: Gnus uses similar metaphors for navigating and parsing information. It still is important to read the manual though.

Now here comes the nice part of leveraging the integration that Emacs offers: in my Org mode configurations I have a simple template to capture the current buffer's link. This means that we can quickly convert any item into a task/note and always be able to go back to the original message by following the link. Found an interesting suggestion in some mailing list? Capture it. Need to act on an email later? Capture, capture, capture. Same principle applies to the integration with Dired as a means of attaching files to emails (see next section).

The package declarations below are divided into several subsections to make things easier to read and keep track of. Remember to use C-h v VAR to read documentation about each VAR or simply place the point over it and then hit C-h v to pre-populate the results (C-h f is the equivalent for functions, C-h o for other symbols). Whenever you see some formatting customisations concerning time units, it is better refer to the documentation of the function format-time-string to understand the meaning of the various date/time specifiers. Gnus account settings and essential configurations

Here I only furnish the essentials for the basic Gnus functionality. Subsequent sections expand on the particulars.

  • The gnus-select-method sets the default method for fetching news items. As I want to read mail from several accounts in addition to following Usenet sources, I choose to set it to nil.
  • The gnus-secondary-select-methods is where my accounts are specified. Each nnimap list points to a specific line in my authinfo.gpg file (whose format I described in the base email settings). My emails all use the same server so this method allows me to specify the username (email) and password combination for each of them without making this information public. I am not sure whether the nnimap-stream and nnimap-authinfo-file are needed, but I keep them for the sake of completeness.
  • The gnus-parameters are designed to move my outgoing messages to the "Sent" folder of the account that replies to a given email and to use the right email address, depending on the context. While the variable gnus-gcc-mark-as-read ensures that the outgoing messages are marked as read. NOTE: the function I currently use to dynamically set the "From" parameter is very fragile. I eventually need to find a robust way of getting the substring. I know how to do it with sed or awk but not while using elisp. Though the code works for the time being…
  • The "agent" is enabled here and configured in the following section.
  • Setting the gnus-novice-user to nil has the effect of reducing prompts for potentially destructive commands, such as deleting an email. Too many confirmations end up being annoying, but you might opt to keep this to t if you are still new to Gnus.
  • The variables concerning the "dribble" file may be reviewed. The idea is to store the state of Gnus in case Emacs crashes. This has never happened and, therefore, I am not putting too much effort into solving a highly unlikely problem.
  • Consider reviewing nnmail-expiry-wait only after you have some experience with Gnus. I set it to a fairly high value.
  • As for the configurations of mm-encode and mml-sec, these are meant to come into effect when encrypting and signing an outgoing message with C-c C-m C-e (mml-secure-message-sign-encrypt). The guided key selection will ask for confirmation on who to encrypt to. It presents a list with the available keys. Items are marked with m and then the mail can be sent with the standard commands (e.g. C-c C-c). I select myself and whomever the other party is. This is an extra step just to make sure that I have everything right with regard to the keys and the correspondent[s] when using encryption. If this becomes a task I use regularly, I will need to streamline things. For the time being, I want the added confirmation.
(use-package gnus
  ;; accounts
  (setq gnus-select-method '(nnnil))
  (setq gnus-secondary-select-methods
        '((nntp "news.gwene.org")
          (nnimap "prv"
                  (nnimap-address "mail.gandi.net")
                  (nnimap-stream ssl)
                  (nnimap-authinfo-file "~/.authinfo.gpg"))
          (nnimap "inf"
                  (nnimap-address "mail.gandi.net")
                  (nnimap-stream ssl)
                  (nnimap-authinfo-file "~/.authinfo.gpg"))
          (nnimap "pub"
                  (nnimap-address "mail.gandi.net")
                  (nnimap-stream ssl)
                  (nnimap-authinfo-file "~/.authinfo.gpg"))))

  (setq gnus-parameters
            (gcc "nnimap+prv:Sent")
             (concat user-full-name " " "<"
              (substring (format "%s" (auth-source-search :host "prv")) 28 51)
            (gcc "nnimap+inf:Sent")
             (concat user-full-name " " "<"
              (substring (format "%s" (auth-source-search :host "inf")) 28 48)
           (posting-style               ; Uses default name+mail
            (gcc "nnimap+pub:Sent")))))
  (setq gnus-gcc-mark-as-read t)
  (setq gnus-agent t)
  (setq gnus-novice-user nil)
  ;; checking sources
  (setq gnus-check-new-newsgroups 'ask-server)
  (setq gnus-read-active-file 'some)
  ;; dribble
  (setq gnus-use-dribble-file t)
  (setq gnus-always-read-dribble-file t)
  :bind ("C-c m" . gnus))

(use-package nnmail
  (setq nnmail-expiry-wait 30))

(use-package mm-encode
  (setq mm-encrypt-option 'guided))

(use-package mml-sec
  (setq mml-secure-openpgp-encrypt-to-self t)
  (setq mml-secure-openpgp-sign-with-sender t)
  (setq mml-secure-smime-encrypt-to-self t)
  (setq mml-secure-smime-sign-with-sender t)) Gnus agent

The "agent" is a technical term described in the Gnus manual which basically represents the bridge between our Gnus and the server to which it connects to. Gnus is said to be "plugged" when a connection is established. Else it is "unplugged".

Technicalities aside, we can use the agent to configure the handling of messages. For example, we can set an expiry date, after which the message is deleted, or we can create a queue of outgoing messages when Gnus is in an unplugged state.

(use-package gnus-agent
  :after gnus
  (setq gnus-agent-article-alist-save-format 1)  ; uncompressed
  (setq gnus-agent-cache t)
  (setq gnus-agent-confirmation-function 'y-or-n-p)
  (setq gnus-agent-consider-all-articles nil)
  (setq gnus-agent-directory "~/News/agent/")
  (setq gnus-agent-enable-expiration 'ENABLE)
  (setq gnus-agent-expire-all nil)
  (setq gnus-agent-expire-days 30)
  (setq gnus-agent-mark-unread-after-downloaded t)
  (setq gnus-agent-queue-mail t)        ; queue if unplugged
  (setq gnus-agent-synchronize-flags nil)) Gnus article (message view)

In Gnus parlance the "article" is the window that contains the summary's news/email currently selected item. This has its own major mode, which is great for us: we can define key bindings that only apply when the article is in focus.

I have no particular interest in the HTML-related variables, because I practically never have to read any such messages. As a general rule, email that can only be read in HTML is likely spam or annoying enough to be treated as such.

Note that gnus-article-sort-functions requires the most important function to be declared last.

With regard to the key bindings, I have redefined some of the existing ones to suit of workflow and better match my intuitions. For example, in the Article view, hitting s takes you to the Summary buffer. I find that to be a waste, since we can already move between buffers with standard keys. Instead, The s can be used to save the attachment at point. Similarly, I want o to behave just like in dired, where it opens the attachment at point (MIME part) in another buffer.

(use-package gnus-art
  :after gnus
  (setq gnus-article-browse-delete-temp 'ask)
  (setq gnus-article-over-scroll nil)
  (setq gnus-article-show-cursor t)
  (setq gnus-article-sort-functions
        '((not gnus-article-sort-by-number)
          (not gnus-article-sort-by-date)))
  (setq gnus-article-truncate-lines nil)
  (setq gnus-html-frame-width 80)
  (setq gnus-html-image-automatic-caching t)
  (setq gnus-inhibit-images t)
  (setq gnus-max-image-proportion 0.3)
  (setq gnus-treat-display-smileys nil)
  (setq gnus-article-mode-line-format "%G %S %m")
  (setq gnus-visible-headers
        '("^From:" "^To:" "^Cc:" "^Newsgroups:" "^Subject:" "^Date:"
          "Followup-To:" "Reply-To:" "^Organization:" "^X-Newsreader:"
  (setq gnus-sorted-header-list gnus-visible-headers)
  :bind (:map gnus-article-mode-map
              ("s" . gnus-mime-save-part)
              ("o" . gnus-mime-copy-part))) Gnus asynchronous operations

By default, Gnus performs all its actions in a synchronous fashion. This means that Emacs is blocked until Gnus has finished. By enabling this library, we can use certain functions in a non-blocking way. I do this for sending email.

(use-package gnus-async
  :after gnus
  (setq gnus-asynchronous t)
  (setq gnus-use-article-prefetch 15)) Gnus group (main interface)

I already outlined the utility of the group buffer in the introductory section on Gnus for reading email, mailing lists, and more. In short, it is the epicentre of Gnus, where all your subscribed groups are presented and from where you can browse through your updates.

I use groups in tandem with topics, which allows me to quickly follow updates on the theme I am interested in at the moment. It also allows me to perform per-topic actions, such as updating only the groups it contains or "catching up" to them (marking them as read).

I choose to disable the default behaviour of always showing a group that has "ticked" items (the equivalent of starred or marked as important).

Note that gnus-group-sort-functions requires the most important function to be declared last.

(use-package gnus-group
  :after gnus
  (setq gnus-level-subscribed 6)
  (setq gnus-level-unsubscribed 7)
  (setq gnus-level-zombie 8)
  (setq gnus-list-groups-with-ticked-articles nil)
  (setq gnus-group-sort-function
  (setq gnus-group-mode-line-format "%%b")
  (gnus-group-mode . hl-line-mode)
  (gnus-select-group-hook . gnus-group-set-timestamp)
  :bind (:map gnus-agent-group-mode-map
              ("M-n" . gnus-topic-goto-next-topic)
              ("M-p" . gnus-topic-goto-previous-topic)))

(use-package gnus-topic
  :after (gnus gnus-group)
  (setq gnus-topic-display-empty-topics nil)
  (gnus-group-mode . gnus-topic-mode)) Gnus summary

This section assumes you have already read my introductory remarks on Gnus for reading email, mailing lists, and more.

Note that the various sort functions expect the primary filter method to be declared last, in case more that one function is to be invoked. The sorting is set to reverse chronological order (newest first).

Threads should not be hidden, while messages whose root has been removed should be grouped together in some meaningful way. Furthermore, when moving up or down in the list of messages using just n or p, I want to go to the next message, regardless of whether it has been read or not. I can otherwise rely on standard Emacs motions.

The formatting of the threads using Unicode characters was taken from the relevant Emacs wiki entry plus some minor tweaks by me.

The gnus-user-date-format-alist, this basically adapts the date to whether the message was within the day or the one before, else falls back to a default value. It is then called with %&user-date;.

(use-package gnus-sum
  :after (gnus gnus-group)
  (setq gnus-auto-select-first nil)
  (setq gnus-summary-ignore-duplicates t)
  (setq gnus-suppress-duplicates t)
  (setq gnus-summary-goto-unread nil)
  (setq gnus-summary-make-false-root 'adopt)
  (setq gnus-summary-thread-gathering-function
  (setq gnus-thread-sort-functions
        '((not gnus-thread-sort-by-date)
          (not gnus-thread-sort-by-number)))
  (setq gnus-subthread-sort-functions
  (setq gnus-thread-hide-subtree nil)
  (setq gnus-thread-ignore-subject nil)
  (setq gnus-user-date-format-alist
        '(((gnus-seconds-today) . "Today at %R")
          ((+ 86400 (gnus-seconds-today)) . "Yesterday, %R")
          (t . "%Y-%m-%d %R")))
  (setq gnus-summary-line-format "%U%R%z %-16,16&user-date;  %4L:%-30,30f  %B%S\n")
  (setq gnus-summary-mode-line-format "%p")
  (setq gnus-sum-thread-tree-false-root "─┬➤ ")
  (setq gnus-sum-thread-tree-indent " ")
  (setq gnus-sum-thread-tree-leaf-with-other "├─➤ ")
  (setq gnus-sum-thread-tree-root "")
  (setq gnus-sum-thread-tree-single-leaf "└─➤ ")
  (setq gnus-sum-thread-tree-vertical "│")
  ;; (defun prot/gnus-summary-save-parts-all ()
  ;;   "Save all MIME parts (attachments) to the ~/Downloads directory."
  ;;   (interactive)
  ;;   (let ((directory "~/Downloads"))
  ;;     (gnus-summary-save-parts ".*" directory)))
  (gnus-summary-mode . hl-line-mode)
  (gnus-summary-exit-hook . gnus-topic-sort-groups-by-alphabet)
  (gnus-summary-exit-hook . gnus-group-sort-groups-by-rank)
  :bind (:map gnus-agent-summary-mode-map
              ("<delete>" . gnus-summary-delete-article)
              ("n" . gnus-summary-next-article)
              ("p" . gnus-summary-prev-article)
              ("N" . gnus-summary-next-unread-article)
              ("P" . gnus-summary-prev-unread-article)
              ("M-n" . gnus-summary-next-thread)
              ("M-p" . gnus-summary-prev-thread)
              ("C-M-n" . gnus-summary-next-group)
              ("C-M-p" . gnus-summary-prev-group)
              ("C-M-^" . gnus-summary-refer-thread))) Gnus server

The "server" is where your news sources are listed and from where you can browse items you would like to subscribe to (e.g. your email account's Inbox or some mailing list on Usenet). Make sure to read about these concepts in the introductory section about Gnus.

(use-package gnus-srvr
  :after gnus
  ((gnus-browse-mode gnus-server-mode) . hl-line-mode)) Gnus intersection with Dired

We can use the built-in directory editor (file manager) as a more convenient way of performing certain tasks that relate to emails, such as attaching all the marked items of the dired buffer to an email we are currently composing or wish to initiate the composition of.

Run C-h m inside of a Dired buffer that has gnus-dired-mode enabled and search for "gnus" to see all the relevant key bindings and the functions they call. I only ever use C-c C-m C-a (C-m is the same as RET).

By the way, make sure to check my comprehensive Dired configurations.

(use-package gnus-dired
  :after (gnus dired)
  :hook (dired-mode . gnus-dired-mode)) TODO Extend Gnus [0/2]   emacs gnus TODO non-blocking RSS feeds (use topic scores?) TODO parse Atom feeds as well?

5.4.3 Sending email (SMTP)

These are the base settings for the SMTP functionality. Passwords and other critical information are stored in ~/.authinfo.gpg, as demonstrated in the base email settings. What follows is just a mirroring of the contents of that file.

With regard to the asynchronous functionality, it is meant to improve performance by carrying out the relevant tasks in a non-blocking way.

(use-package smtpmail
  (setq smtpmail-default-smtp-server "mail.gandi.net")
  (setq smtpmail-smtp-server "mail.gandi.net")
  (setq smtpmail-stream-type 'ssl)
  (setq smtpmail-smtp-service 465)
  (setq smtpmail-queue-mail nil))

(use-package smtpmail-async
  :after smtpmail
  (setq send-mail-function 'async-smtpmail-send-it)
  (setq message-send-mail-function 'async-smtpmail-send-it))

5.4.4 Contact management (EBDB)

This is a contact manager that integrates nicely with Gnus (see previous sections in email settings). It is an alternative to the more established bbdb package. I use it to store names and addresses from my email correspondence. Nothing fancy here.

ebdb has a comprehensive manual and a broad range of customisation options. My needs are simple though, as I have basically lived without any contact management app for ages (I practised “social distancing” before it became a thing!).

This is how EBDB works inside of the Gnus "Summary" or "Article" buffers:

  • Hit ; ; to display a window on the side of the message with information about the records in the database that correspond to those in the message. If no record exists, the window will not be displayed. Alternatively, set ebdb-mua-pop-up to t to always get the window, whether empty or not.
  • With ; : you can create new database entries with the information harvested from the current message. There are ways to make this automatic, but I did not experiment with them. If I store someone's contact information, it means I have used it before or have a clear intent to do so. No automatic records, please.
  • Type ; followed by C-h to bring up a help buffer with all the available keybindings (this works for every key chord, by the way).

Some useful commands that are not specific to Gnus:

  • In a message composition buffer (using e.g. the compose-mail bound to C-x m), hit TAB while in a header field where emails are appropriate to either complete what you have typed in or get feedback on possible completion candidates.
  • ebdb-cite-records lets you input a contact in the current buffer. If you do this in an org-mode buffer, it will prefix the email address with a mailto: tag.

It is also possible to connect EBDB with the Diary and with Org's Agenda views. I have no use for such features. If, however, my needs ever evolve to something more demanding, I am confident this tool will cope with them. For the time being, this package declaration is enough.

(use-package ebdb
  :ensure t
  :pin gnu                              ; Prefer ELPA version
  (require 'ebdb-gnus)
  (require 'ebdb-message)
  (setq ebdb-default-window-size 0.2)
  (setq ebdb-mua-pop-up nil)
  (setq ebdb-mua-auto-update-p 'query)
  (setq ebdb-mua-sender-update-p 'query)
  (setq ebdb-mua-reader-update-p 'query)
  (setq ebdb-add-aka 'query)
  (setq ebdb-add-name 'query)
  (setq ebdb-add-mails 'query))

5.5 Git front-end (Magit) and relevant configurations

I was already well-versed in the CLI commands for git, but I feel that magit offers an intuitive interface that speeds up most common tasks. The real reason I use it though, is because it makes it easier to perform git operations while inside a directory/file. No need to switch to a terminal emulator.

5.5.1 Base Magit settings

Magit has good defaults. I only found a few things that I would like to customise, which I do in the following package declarations.

(use-package magit
  :ensure t
  :bind (("C-c g" . magit-status)
         ("s-g" . magit-status)))

5.5.2 Git commits

The following package is configured in accordance with the guidelines provided by this article on writing a Git commit message. The gist is to write commits that are clean and easy to read. The fill-column is set elsewhere in this document to 72 characters long.

(use-package git-commit
  :after magit
  (setq git-commit-summary-max-length 50)
  (setq git-commit-known-pseudo-headers
  (setq git-commit-style-convention-checks

5.5.3 Git diffs

The settings below are for the diff screens that Magit produces. I just want to highlight changes within a line, not just the line itself. I enable it only for the focused hunk (there is an option for 'all).

My Modus themes are configured to style these appropriately.

(use-package magit-diff
  :after magit
  (setq magit-diff-refine-hunk t))

And this covers the built-in diff mode, which I seldom use. Both of these variables were introduced in Emacs 27.1.

(use-package diff
  (setq diff-font-lock-prettify nil)
  (setq diff-font-lock-syntax nil))

5.5.4 Magit repo list

When maintaining a number of projects, it sometimes is necessary to produce a full list of them with their corresponding Magit status. That way you can determine very quickly which repositories need to be examined further.

(use-package magit-repos
  :after magit
  :commands magit-list-repositories
  (setq magit-repository-directories
        '(("~/Git/Projects" . 1))))

5.5.5 Git time machine

One of the major upsides of keeping files under version control is the ability to revert to a previous state in the history of changes. By using git-timemachine we can flip through a file's full list of permutations. Reverting to a given phase is as easy as writing the buffer to a file, with C-x C-w. In general, it might be better to save a version as a different file and then run M-x diff between the two. Or maybe you want to do so with three files, in which case M-x ediff3 is your friend.

Once inside the time machine, hit ? to get a help interface with the available key bindings. These extend magit functionality.

(use-package git-timemachine
  :ensure t
  :commands git-timemachine)

5.6 Shells and terminal emulators

5.6.1 Shell (M-x shell)

This is a shell (Bash, in my case) that runs inside of Emacs. Unlike term (see next section), this one can use standard Emacs keys and behaves like an ordinary buffer. The one area where it differs substantially from ordinary buffers is with regard to the command prompt: you can re-run a command on the scroll-back buffer by just hitting RET while point is on its line (no need to go back to the end and cycle the command history with M-p or M-n).

Note that I am well aware of eshell. I read the manual and checked lots of configurations about it. I still do not see a major improvement over Bash, notwithstanding the significant downside of having to learn the idiosyncrasies of yet another tool. Besides, many of the features of eshell are already available inside of Emacs and are accessible via more appropriate interfaces (e.g. find-file or dired powered by a completion framework like the one I specify in a previous section of this document about Minibuffer essentials and Icomplete). The shell has to behave consistently whether I run it inside of Emacs, in Xterm, or just a TTY. Everything else introduces friction.

Run C-h m inside of a shell buffer to learn about all the key bindings and corresponding functions.

(use-package shell
  :commands shell-command
  (setq ansi-color-for-comint-mode t)
  (setq shell-command-prompt-show-cwd t) ; Emacs 27.1

  (defun prot/shell-multi ()
    "Spawn a new instance of `shell' and give it a unique name
based on the directory of the current buffer."
    (let* ((parent (if (buffer-file-name)
                       (file-name-directory (buffer-file-name))
           (name (car (last (split-string parent "/" t)))))
      (with-current-buffer (shell)
         (generate-new-buffer-name (concat "*shell: " name "*"))))))
  :bind (("<s-return>" . shell)
         ("<s-S-return>" . prot/shell-multi)))

5.6.2 Terminal emulators

term and ansi-term are terminal emulators like Xterm. Not to be confused with command line shells such as Bash. They run inside of Emacs but are basically alien to the rest of the Emacs milieu: they do not reuse standard key bindings like C-y.

Only use those if you absolutely need one AND you have no access to a standalone, fully fledged terminal emulator.

As far as I can tell, based on reading the comments in term.el and elsewhere in the docs, the major difference between term and ansi-term is the ability of the latter to run one or multiple buffers simultaneously. Better check the documentation for this point. It does not seem to be a strong point, since this is also possible with the other options in the Emacs space (e.g. with C-u M-x shell).

(use-package term
  :commands term
  (setq term-buffer-maximum-size 9999)
  (setq term-completion-autolist t)
  (setq term-completion-recexact t)
  (setq term-scroll-to-bottom-on-output t))

5.7 Proced (process monitor, similar to `top')

This is a built-in tool that allows you to monitor running processes and act on them accordingly. These are the basic settings I have right now. Would need to experiment with it a bit more. It works fine though.

(use-package proced
  :commands proced
  (setq proced-auto-update-flag t)
  (setq proced-auto-update-interval 1)
  (setq proced-descend t)
  (setq proced-filter 'user))

5.8 Pass interface (password-store)

The external pass program, aka "password-store", is a password manager that uses GPG and standard UNIX tools to handle passwords. Encrypted files are stored in a plain directory structure. Very simple, very nice: now all data is available with a variety of interfaces, such as standard CLI, a dmenu interface, a graphical front-end like qtpass, etc.

The package below provides an Emacs interface to some of the most common actions, in the form of a list of candidates that can be narrowed down (such as with icomplete). I use it to quickly store a password to the kill ring.

(use-package password-store
  :ensure t
  :commands (password-store-copy
  (setq password-store-time-before-clipboard-restore 30))

And this one adds a major mode for browsing the pass keychain. Call it with M-x pass. There is a helpful section at the top with key bindings and their functions.

(use-package pass
  :ensure t
  :commands pass)

5.9 Elfeed (feed reader for RSS/Atom)

Settings for the feed reader package. I mostly care about the unique buffers tweak. It allows me to open a feed entry and keep it around while I go on browsing the feed list.

Here is the source code on Gitlab for ambrevar/elfeed-play-with-mpv, with minor tweaks by me.

(use-package elfeed
  :ensure t
  :commands elfeed
  (setq elfeed-use-curl t)
  (setq elfeed-curl-max-connections 10)
  (setq elfeed-db-directory "~/.emacs.d/elfeed")
  (setq elfeed-enclosure-default-dir "~/Downloads")
  (setq elfeed-search-clipboard-type 'CLIPBOARD)
  (setq elfeed-search-title-max-width (current-fill-column))
  (setq elfeed-search-title-max-width 100)
  (setq elfeed-search-title-min-width 30)
  (setq elfeed-search-trailing-width 16)
  (setq elfeed-show-truncate-long-urls t)
  (setq elfeed-show-unique-buffers t)

  (defun prot/feeds ()
    "Loads a file with RSS/Atom feeds.  This file contains valid
syntax for use by the `elfeed' package."
    (let ((feeds "~/.emacs.d/feeds.el.gpg"))
      (when (file-exists-p feeds)
        (load-file feeds))))

  (defun ambrevar/elfeed-play-with-mpv ()
    "Play entry link with mpv."
    (let ((entry (if (eq major-mode 'elfeed-show-mode)
                     elfeed-show-entry (elfeed-search-selected :single)))
          (quality-arg "")
          (quality-val (completing-read "Resolution: "
                                        '("480" "720" "1080")
                                        nil nil)))
      (setq quality-val (string-to-number quality-val))
      (message "Opening %s with height≤%s..."
               (elfeed-entry-link entry) quality-val)
      (when (< 0 quality-val)
        (setq quality-arg
              (format "--ytdl-format=[height<=?%s]" quality-val)))
      (start-process "elfeed-mpv" nil "mpv"
                     quality-arg (elfeed-entry-link entry))))
  :hook (after-init . prot/feeds)
  :bind (:map elfeed-search-mode-map
              ("v" . (lambda ()
              ("w" . elfeed-search-yank)
              ("g" . elfeed-update)
              ("G" . elfeed-search-update--force)
              :map elfeed-show-mode-map
              ("v" . ambrevar/elfeed-play-with-mpv)
              ("w" . elfeed-show-yank)))

5.10 Emacs web browser and HTML parser

As far as I can tell, the following shr-* variables concern an HTML parser that is used by a variety of tools, including Elfeed (defined right above). I guess we could scope them by using hooks, but I see no need for different settings.

What these do:

  • Open links in a new Emacs window, instead of the system's browser. This Emacs web browser is called eww.
  • Use monospaced fonts, since that is what I want to have everywhere in Emacs.
  • Do not preserve colours from websites, as they may be inaccessible (see my Modus theme).
  • Keep images to 20% of the window. This number is arbitrary. It just feels like a good upper limit (not a fan of decorative images inside of blog posts).
  • Line length at same number of characters as fill-column (defined elsewhere in this doc at 72).
(use-package shr
  :commands (eww
  (setq browse-url-browser-function 'eww-browse-url)
  (setq shr-use-fonts nil)
  (setq shr-use-colors nil)
  (setq shr-max-image-proportion 0.2)
  (setq shr-width (current-fill-column)))

Support the HTML pre tag with proper syntax highlighting. Got this snippet directly from its GitHub project page.

(use-package shr-tag-pre-highlight
  :ensure t
  :after shr
  (add-to-list 'shr-external-rendering-functions
               '(pre . shr-tag-pre-highlight))
  (when (version< emacs-version "26")
    (with-eval-after-load 'eww
      (advice-add 'eww-display-html :around

5.11 Bongo (Music player)

I already tried EMMS and various other options but did not stick with them. I felt I was missing something or maybe I just tested them too early into my Emacs journey. Now using Bongo and am quite happy with it.

Concerning the customisations below, these can be summarised thus:

  • Hide icons.
  • No mode line indicators.
  • Do not ask for directory tree insertion.
  • With Dired, the "Music" directory doubles as a Bongo library (see prot/bongo-dired-library and the relevant hook).
  • Because of the above, prefer playlist buffers (pro tip: you can use dired-jump inside of a playlist buffer to switch to that directory—see my Dired section for the relevant configs).
  • While contrib/bongo-add-dired-file integrates Dired mark command with Bongo. The function is provided in this Emacs Wiki entry (minor tweaks by me).

The way I play music is very simple. I load up a directory tree with a bunch of audio files. Then I C-u C-c C-r from inside a Bongo buffer to play the tracks in random order. Done! I rarely switch tracks manually and change playlists in regular intervals (a directory tree typically contains hundreds of music files).

This sequence is conveniently mapped to C-RET inside of the Bongo Library buffer (so the Dired buffer of ~/Music and its sub-directories). The command will operate on the directory at point or on the marked items, if they exist. Note that I used to bind that action to just SPC but I realised it would interfere with tasks in wdired (and probably elsewhere).

I have a couple of videos about my workflow with Bongo and Dired:

(use-package bongo
  :ensure t
  :commands bongo
  (setq bongo-default-directory "~/Music")
  (setq bongo-prefer-library-buffers nil)
  (setq bongo-insert-whole-directory-trees t)
  (setq bongo-logo nil)
  (setq bongo-action-track-icon nil)
  (setq bongo-display-track-icons nil)
  (setq bongo-display-track-lengths nil)
  (setq bongo-display-header-icons nil)
  (setq bongo-display-playback-mode-indicator t)
  (setq bongo-display-inline-playback-progress nil)
  (setq bongo-mark-played-tracks nil)
  (setq bongo-header-line-mode nil)
  (setq bongo-header-line-function nil)
  (setq bongo-mode-line-indicator-mode nil)
  (setq bongo-vlc-program-name "cvlc")

  (defun contrib/bongo-add-dired-files ()
    "Add marked files inside of a Dired buffer to the Bongo library"
    (let (file-point file (files nil))
       (setq file-point (dired-move-to-filename)
             file (dired-get-filename)
             files (append files (list file)))
       nil t)
        (set-buffer bongo-default-playlist-buffer-name)
        (mapc 'bongo-insert-file files))))

  (defun prot/bongo-dired-library ()
    "Set `bongo-dired-library-mode' when accessing ~/Music.

This is meant to be hooked to `dired-mode'.  Upon activation, the
directory and all its sub-directories become a valid library
buffer for Bongo, from where we can, among others, add tracks to
playlists.  The added benefit is that Dired will continue to
behave as normal, making this a superior alternative to a
purpose-specific library buffer."
    (when (string-match-p "\\`~/Music/" default-directory)
      (set (make-local-variable 'bongo-dired-library-mode) 't)))

  (defun prot/bongo-clear-playlist-and-stop ()
    "Stop playback and clear the entire `bongo' playlist buffer.

Contrary to the standard `bongo-erase-buffer', this also removes
the currently-playing track."
    (when (bongo-playlist-buffer-p)

  (defun prot/bongo-play-random ()
    "Play a random track with `bongo' and set random playback."
    (when (or (bongo-playlist-buffer-p)
      (bongo-random-playback-mode 1)))

  (defun prot/bongo-library-insert-and-play-random ()
    "Add directory tree or marked items to the `bongo' playlist.

This is meant to work while inside a `dired' buffer that doubles
as a library buffer (see `prot/bongo-dired-library')."
    (when (bongo-library-buffer-p)

  (defun prot/bongo-insert-playlist ()
    "Insert the contents of a `bongo' playlist.

The files are stored in a predetermined path inside my Music

Upon insertion, playback starts immediately, in accordance with
    (let* ((path "~/Music/playlists/")
           (dotless directory-files-no-dot-files-regexp)
           (playlists (mapcar
                       (directory-files path t dotless))))
      (when (bongo-playlist-buffer-p)
        ;;;; Enables vertical completion while using `icomplete'.  I do
        ;;;; not need this right now, since there is only a handful of
        ;;;; playlists and all of them are in the same path so that a
        ;;;; couple of key presses give a unique match anyway.
        ;; (when (bound-and-true-p icomplete-mode)
        ;;   (prot/icomplete-show-vertical))
         (completing-read "Select playlist: " playlists nil t))

  :hook ((dired-mode . prot/bongo-dired-library)
         (bongo-playlist-mode . hl-line-mode))
  :bind (("<C-XF86AudioPlay>" . bongo-pause/resume)
         ("<C-XF86AudioNext>" . bongo-next)
         ("<C-XF86AudioPrev>" . bongo-previous)
         ("<M-XF86AudioPlay>" . bongo-show)
         :map bongo-playlist-mode-map
         ("C-d" . prot/bongo-clear-playlist-and-stop)
         ("I" . prot/bongo-insert-playlist)
         :map bongo-dired-library-mode-map
         ("<C-return>" . prot/bongo-library-insert-and-play-random)))

6 General interface and interactions

This section contains configurations for all aspects of the Emacs user interface, as well lots of small or self-contained tweaks that cover a wide range of built-in libraries.

6.1 Disable GUI components

Overview of these settings:

  • I normally use the GTK (GUI) variant of Emacs. I prefer not to have any of the elements that come with it. This keeps the window clean. The only "interface" component that remains in place is the mode line, which is not part of the GUI toolkit anyway…
  • The start-up screen that offers an overview of GNU Emacs is also disabled. It is useful for beginners, but is rendered obsolete once you familiarise yourself with the essentials.
  • The pair of key bindings that involve z minimise the Emacs frame. This is technically an interface action, in that it assumes my window manager has a minimise function or that I want to have such a motion inside of Emacs. Disable them.
  • Also disable the "hello file" function, because it crashes Emacs. I assume this has to do with font rendering and missing font files, as I experienced similar issues on various terminal emulators.
(use-package emacs
  (menu-bar-mode -1)
  (tool-bar-mode -1)
  (scroll-bar-mode -1)
  (setq use-file-dialog nil)
  (setq use-dialog-box t)               ; only for mouse events
  (setq inhibit-splash-screen t)
  (global-unset-key (kbd "C-z"))
  (global-unset-key (kbd "C-x C-z"))
  (global-unset-key (kbd "C-h h")))

6.2 Modus themes (my very accessible themes) and other visuals

I am using my own themes. They are designed to conform with the highest accessibility standard for colour contrast between foreground and background values. This stands for a minimum contrast ratio of 7:1, also known as the WCAG AAA standard. In simpler terms, they are good for readability.

I call this project "Modus themes". It consists of "Modus Operandi" (light theme) and "Modus Vivendi" (dark). The source code and installation instructions are available on their GitLab page. The list of supported packages is comprehensive.

The themes are available in the official ELPA repository (latest tagged release), MELPA (latest commit to the master branch), as well as MELPA Stable (latest tag).

They are distributed as standalone packages as of December 1, 2019 under the terms of the GNU General Public License. I did it that way instead of publishing them as a single package because I know that people tend to use one or the other. And also due to the fact that one is not a prerequisite for the other. I personally use both, switching between them depending on the ambient light in my room.

Note though that because I am using these themes locally as part of their development process, I am not using the ELPA/MELPA packages directly.

Lastly, if you are curious about the underlying methodology, read my essay on the on the design of the Modus themes (2020-03-17).

(use-package emacs
  (setq custom-safe-themes t)

  (defun prot/modus-operandi ()
    "Enable some `modus-operandi' variables and load the theme."
    (setq modus-operandi-theme-slanted-constructs t
          modus-operandi-theme-bold-constructs nil
          modus-operandi-theme-visible-fringes t
          modus-operandi-theme-distinct-org-blocks nil
          modus-operandi-theme-proportional-fonts nil
          modus-operandi-theme-scale-headings t
          modus-operandi-theme-scale-1 1.05
          modus-operandi-theme-scale-2 1.1
          modus-operandi-theme-scale-3 1.15
          modus-operandi-theme-scale-4 1.2)
    (load-theme 'modus-operandi t))

  (defun prot/modus-vivendi ()
    "Enable some `modus-vivendi' variables and load the theme."
    (setq modus-vivendi-theme-slanted-constructs t
          modus-vivendi-theme-bold-constructs nil
          modus-vivendi-theme-visible-fringes t
          modus-vivendi-theme-distinct-org-blocks nil
          modus-vivendi-theme-proportional-fonts nil
          modus-vivendi-theme-scale-headings t
          modus-vivendi-theme-scale-1 1.05
          modus-vivendi-theme-scale-2 1.1
          modus-vivendi-theme-scale-3 1.15
          modus-vivendi-theme-scale-4 1.2)
    (load-theme 'modus-vivendi t))

  (defcustom prot/modus-themes-toggle-hook nil
    "Hook that runs after `prot/modus-themes-toggle' is invoked."
    :type 'hook)

  (defun prot/modus-themes-toggle ()
    "Toggle between `modus-operandi' and `modus-vivendi' themes.

Also run `prot/modus-themes-toggle-hook'."
    (if (eq (car custom-enabled-themes) 'modus-operandi)
    (run-hooks 'prot/modus-themes-toggle-hook))

  (defun prot/describe-face (pos)
    "Print message with name of face[s] at point.

A lightweight alternative to `what-cursor-position' and its
prefixed variant."
    (interactive "d")
    (let ((face (or (get-char-property pos 'face)
                    (get-char-property pos 'read-cf-name))))
      (message "%s" (or face
                        "No face at point"))))

  :bind (("<f5>" . prot/modus-themes-toggle)
         ("s-=" . prot/describe-face))
  :hook (after-init . prot/modus-operandi))

6.2.1 Mode line

The mode line is an integral part of the Emacs interface. While there are lots of third party packages that style it in a variety of ways, I find the default to be particularly good.

I just configure it to hide the Git/VC status. Its utility is marginal at best. Then I reshuffle some of the remaining indicators. Nothing too fancy.

Meanwhile, the mode-line-defining-kbd-macro is tweaked to use a more appropriate string for its indicator and colours that are designed specifically for the mode line (the default uses the generic font-lock warning face).

(use-package emacs
  (setq mode-line-percent-position '(-3 "%p"))
  (setq mode-line-defining-kbd-macro
        (propertize " Macro" 'face 'mode-line-emphasis))
  (setq-default mode-line-format
                  "  "
                  " "
                  " "

In the following sub-sections I provide customisations for some tools that place information on the mode line. Again, nothing flamboyant. Battery status

Emacs offers a built-in library for presenting information about the status of the laptop's battery. Using it allows me to eliminate my dependence on the system panel and thus keep Emacs in full screen view without any interruptions.

The default update interval is set to a single minute (in seconds), which is generally fine though I find that a slightly higher value works just as well. As for the format, it is designed to show a context-dependent, single character indicator about the current status, as well as the battery's overall percentage.

Variable battery-mode-line-limit will hide the indicator if the value is above the declared threshold. 99 basically means "full". I use that instead of a 100 because sometimes the battery only ever fills up to 99.99, meaning that the indicator remains present at all times.

(use-package battery
  (setq battery-mode-line-format " [%b%p%%]")
  (setq battery-mode-line-limit 99)
  (setq battery-update-interval 180)
  (setq battery-load-low 20)
  (setq battery-load-critical 10)
  :hook (after-init . display-battery-mode)) Display current time

I normally use Emacs in fullscreen view. No system panels, no window decorations, no icons and blinking indicators. Nothing to distract me. While I really like this environment, sometimes I need to take a look at the time… Thankfully Emacs offers a convenient, built-in way of displaying such information in the mode line.

The display-time-format can be configured to show the current date and time in all the various formats we would expect, using a string of specifiers (find the docs with C-h v format-time-string). Setting its value to nil means that the information on display will be the combined result of display-time-24hr-format and display-time-day-and-date. I prefer to just write a string directly, keeping those two inactive.

The display-time-mode can output more than just the current time. It also shows the load average and an email indicator. I only need the time and date. The rest is noise.

(use-package time
  (setq display-time-format "%Y-%m-%e  %H:%M")
  ;;;; Covered by `display-time-format'
  ;; (setq display-time-24hr-format t)
  ;; (setq display-time-day-and-date t)
  (setq display-time-interval 60)
  (setq display-time-mail-directory nil)
  (setq display-time-default-load-average nil)
  :hook (after-init . display-time-mode)) Keycast mode

Once enabled, this package uses the mode line to show the keys being pressed and the command they call. It is quite useful for screen casting.

The placement of the indicator is controlled by keycast-window-predicate which I set to the current window. The moody library offers that specific piece of functionality. Moody can also be used to customise the looks of the mode line, though I do not want that.

(use-package moody
  :ensure t)

(use-package keycast
  :ensure t
  :after moody
  :commands keycast-mode
  (setq keycast-window-predicate 'moody-window-active-p)
  (setq keycast-separator-width 1)
  (setq keycast-insert-after 'mode-line-buffer-identification)
  (setq keycast-remove-tail-elements nil))

6.2.2 Window divider mode

This is a built-in mode that allows us to display configurable (and theme-able) window dividers. Whereas the default is to draw a single pixel line using the primary foreground value of the current theme.

The configurations below produce virtually the same results as with the generic window border, only the colour of the divider is less intense (has a grey colour compared to pure white/black). Here is an excerpt of what I had to write about it in commit 373178f8 to my Modus themes:

The default width of the divider is 6 pixels. The first and last pixels are meant as narrow outlines that are drawn in a slightly more intense colour than the remaining 4 inner pixels.

Due to the possibility of adjusting the thickness of the divider, plus the generous default width, the colours I have chosen are less intense than those used in the default window border (those are black on white and vice versa, as per the value of the `default' face).

(use-package emacs
  (setq window-divider-default-right-width 1)
  (setq window-divider-default-bottom-width 1)
  (setq window-divider-default-places 'right-only)
  :hook (after-init . window-divider-mode))

6.2.3 Fringe mode

The fringes are areas to the right and left side of an Emacs frame. They can be used to show status-related or contextual feedback such as line truncation indicators, continuation lines, code linting markers, etc.

The default fringe width is 8 pixels on either side, which I approve of. The value of the fringe-mode I define below allows us to control each side independently. In practice, I could use a single number to apply it to both sides, but this way is better for raising awareness of the possibility.

The use of setq-default is necessary, otherwise these values become buffer-local.

(use-package fringe
  (fringe-mode '(8 . 8))
  (setq-default fringes-outside-margins nil)
  (setq-default indicate-buffer-boundaries nil)
  (setq-default indicate-empty-lines nil)
  (setq-default overflow-newline-into-fringe t))

6.2.4 Diff highlights in the fringe

The diff-hl package uses the left or right fringe to highlight changes in the current buffer. The indicators are colour-coded to denote whether a change is an addition, removal, or change that includes a bit of both.

The package offers some more features, such as the ability to move between diff hunks while editing the buffer. I still need to experiment with those before customising them to my liking.

(use-package diff-hl
  :ensure t
  (setq diff-hl-draw-borders nil)
  (setq diff-hl-side 'left)
 :hook ((after-init . global-diff-hl-mode)))

6.2.5 Optional visual indicators or layout elements

This is a collection of modes or interfaces I seldom use or, rather, I use under special circumstances. They are useful, but there is not need for them to be available at all times. Tabs for window layouts and buffers (Emacs 27.1)

Starting with version 27.1, Emacs has built-in support for two distinct concepts of "tabs":

  1. Spaces that contain windows in any given layout.
  2. A list of buffers presented as buttons at the top of the window.

The former, represented by the tab-bar library is best understood as the equivalent of "virtual desktops", as these are used in most desktop environments or minimalist window managers.

The latter, implemented in tab-line, is the same as the tabs you are used to in web browsers. Each buffer is assigned to a single tab. Clicking on the tab takes you to the corresponding buffer.

I do not need the tab-line as I find such tabs to be inefficient at scale. Finding a buffer through search mechanisms is generally faster: it does not matter whether you have ten or a hundred buffers on the list (unless, of course, they all have similar names in which case you are in trouble either way).

On the other hand, the workspaces (tab-bar) can prove very useful for organising the various applications that are running inside of Emacs. You can, for example, have your current project on tab (workspace) 1, your email and news reader on 2, music on 3, and so on. Of course, this can also be achieved by using separate frames for each of these, though I generally prefer working with a single frame.

At any rate, I do not need the tab bar to be active at all times. I enable it manually when it is necessary. This might change in the future as I experiment more with it as part of my workflow.

(use-package tab-bar
  :commands (tab-bar-mode tab-bar-history-mode)
  (setq tab-bar-close-button-show t)
  (setq tab-bar-close-last-tab-choice nil)
  (setq tab-bar-close-tab-select 'recent)
  (setq tab-bar-new-tab-choice t)
  (setq tab-bar-new-tab-to 'rightmost)
  (setq tab-bar-position nil)
  (setq tab-bar-show 1)
  (setq tab-bar-tab-hints nil)
  (setq tab-bar-tab-name-function 'tab-bar-tab-name-current)

  (tab-bar-mode -1)
  (tab-bar-history-mode -1))

;; This is only included as a reference.
(use-package tab-line
  :commands (tab-line-mode global-tab-line-mode)
  (global-tab-line-mode -1)) Current line highlight (hl-line-mode)

This is a mode that I only activate via hooks for certain buffers where the current line itself is more important that the actual column (e.g. in Dired buffers). Here I configure it so that the highlight applies only to the current window. There is also a "global" variant, for when the equivalent mode is used (I have no plan to use that).

(use-package hl-line
  (setq hl-line-sticky-flag nil)) Rainbow mode for colour testing

The following package reads a colour value, such as hexadecimal RGB, and sets the background for the value in that colour. Quite useful when reviewing my themes (rainbow-mode is activated manually).

(use-package rainbow-mode
  :ensure t
  :commands rainbow-mode
  (setq rainbow-ansi-colors nil)
  (setq rainbow-x-colors nil)) Toggles for line numbers and whitespace indicators
Display line numbers (buffer-local)
I seldom use line numbers, but here it is. This toggles the setting for the local buffer. A global option is also available, but I prefer the buffer-specific variant because there are contexts where global display is not useful (such as occur).
Display invisible characters (whitespace)
Viewing invisible characters (whitespace) can be very helpful under certain circumstances. Generally though, I do not keep it active.
(use-package emacs
  (defun prot/toggle-invisibles ()
    "Toggles the display of indentation and space characters."
    (if (bound-and-true-p whitespace-mode)
        (whitespace-mode -1)

  (defun prot/toggle-line-numbers ()
    "Toggles the display of line numbers.  Applies to all buffers."
    (if (bound-and-true-p display-line-numbers-mode)
        (display-line-numbers-mode -1)
  :bind (("<f6>" . prot/toggle-invisibles)
         ("<f7>" . prot/toggle-line-numbers))) “Focus mode” for writing (olivetti-mode)

I spend much of my time in Emacs reading and writing long form texts. It is nice to be able to easily toggle a mode that centres the buffer, allowing for greater confort.

Olivetti fulfils that niche very nicely. It is not aggressive in its interface requirements while it does not introduce functionality beyond the scope of bringing the current window's buffer to the centre of the view. This is exactly what I need. Any other enhancement, such as a a larger font size can be handled by another function.

The prot/olivetti-mode offers a toggle for activating this mode, while removing the fringes (check my fringe-mode settings) and setting a larger font size.

Note that for my simple presentations inside of Emacs (org-tree-slide) I use darkroom instead of olivetti. They offer similar features, except that the former hides the mode line, giving the faux slide-show effect that is so pertinent to presentations.

(use-package olivetti
  :ensure t
  (setq olivetti-body-width 100)
  (setq olivetti-minimum-body-width 72)
  (setq olivetti-recall-visual-line-mode-entry-state t)

  (defun prot/olivetti-mode ()
    "Toggle `olivetti-mode' without fringes and larger fonts."
    (if olivetti-mode
          (olivetti-mode -1)
          (fringe-mode '(8 . 8))
      (olivetti-mode 1)
      (fringe-mode '(0 . 0))
  :bind ("C-c o" . prot/olivetti-mode)) Rainbow blocks

This package is quite useful when debugging highly structured code that you are not familiar with. It will highlight an entire code block in a single colour, making it easier to understand the overall structure (my Modus themes support it, of course).

Also note that there is another package that applies a rainbow effect only to the delimiters. Between the two, I prefer this one. At any rate, I activate rainbow-blocks-mode manually, when I feel that I am missing something that I cannot spot right away.

A less intrusive, built-in alternative is to set the variable show-parent-style 'expression (see my configs for parentheses).

(use-package rainbow-blocks
  :ensure t
  :commands rainbow-blocks-mode
  (setq rainbow-blocks-highlight-braces-p t)
  (setq rainbow-blocks-highlight-brackets-p t)
  (setq rainbow-blocks-highlight-parens-p t))

6.3 Language settings for prose and code

This section is all about configurations and packages that deal with natural or programming language enhancements.

6.3.1 Line length (column count)

The column count is set to 72. The standard line length is 80 characters, so having it at something less allows for such things as quoting plain text, indenting, etc. git commit messages also make good use of this method. The column count is used by auto-fill-mode and similar tools (or when manually invoking text formatting with M-q).

(use-package emacs
  (setq-default fill-column 72)
  (setq sentence-end-double-space t)
  (setq sentence-end-without-period nil)
  (setq colon-double-space nil)
  :hook (after-init . column-number-mode))

6.3.2 Recognise subwords

It is better you do C-h f subword-mode. Basically, this alters the way Emacs understands word boundaries. So, camelCaseWords are exposed as their constituents rather than one long word, meaning that motions will behave accordingly.

(use-package subword
  :hook (prog-mode . subword-mode))

6.3.3 Auto-fill plain text and comments

Make sure we run the mode that keeps paragraphs within the column limit. The adaptive mode improves the handling of things like bulleted and numbered lists.

(use-package emacs
  :hook (text-mode . (lambda ()
                       (delight 'auto-fill-function nil t)
                       (setq adaptive-fill-mode t))))

6.3.4 Comment lines, regions, boxes, etc.

Just some basic configurations for commenting structured text. This is mostly a placeholder for potentially more targeted and detailed settings that would involve per-mode hooks.

The purpose of my reviewed key bindings is to make them more consistent. Helps with mnemonics. They also are more ergonomic. To this end, I have the following:

  • The standard commenting function is now bound to the simple C-;. This runs a "do what I meant" function I have defined, whose detailed documentation can be read below.
  • C-: (C-S-;) will kill the comment on the current line. This is particularly helpful when the comment follows text you would like to keep. The operation can be performed regardless of where the point is on the line. Some modes disable this behaviour (e.g. trying it on source code inside of org-mode—for those cases, focus the block with C-c ').
  • The M-; will just append a comment to the line, rather than the default comment-dwim.

Note that C-; is occupied by some flyspell command that I have no use for (disabled in the relevant package declaration).

Lastly, use M-j (alias C-M-j) when you want to continue an existing comment on a new line with respect for the current indentation. If you are not inside of a comment, this will just create an indentation-aware new line.

(use-package newcomment
  (setq comment-empty-lines t)
  (setq comment-fill-column nil)
  (setq comment-multi-line t)
  (setq comment-style 'multi-line)

  (defun prot/comment-dwim (&optional arg)
    "Alternative to `comment-dwim': offers a simple wrapper
around `comment-line' and `comment-dwim'.

If the region is active, then toggle the comment status of the
region or, if the major mode defines as much, of all the lines
implied by the region boundaries.

Else toggle the comment status of the line at point."
    (interactive "*P")
    (if (use-region-p)
        (comment-dwim arg)
        (comment-line arg))))

  :bind (("C-;" . prot/comment-dwim)
         ("C-:" . comment-kill)
         ("M-;" . comment-indent)
         ("C-x C-;" . comment-box)))

6.3.5 Flyspell (spell check)

I need spell checking for both English and Greek. In previous versions of this section I had configurations that would automate spell checking for both languages at once. It worked but was rather slow.

Upon further inspection, I have realised that I seldom need to work in mixed language circumstances. Moreover, I now understand that I do not need to have spell checking always on. It can be activated manually, with the flyspell functions defined in the :commands segment below. It is thus possible to keep things simple and to switch dictionaries only when necessary.

Also bear in mind that the key binding C-; is disabled because I re-purpose that for a faster version of C-x C-; (much more useful for my work—see the section on comments).

The two functions I define are meant to ease my workflow, while superseding the default binding for ispell-word. What I normally use is my M-$, which will spell-check the active region or toggle the dictionaries I use. The C-M-$ is defined as a fallback option in case I have already highlighted a region and then realise I need the other dictionary.

Note that aspell and its dictionaries are not part of Emacs. I install the relevant packages from my distro's archive.

(use-package flyspell
  :commands (ispell-change-dictionary
  (setq flyspell-issue-message-flag nil)
  (setq flyspell-issue-welcome-flag nil)
  (setq ispell-program-name "aspell")
  (setq ispell-dictionary "en_GB")

  (defun prot/ispell-toggle-dictionaries ()
    "Toggle between English and Greek dictionaries."
    (if (string= ispell-current-dictionary "en")
        (ispell-change-dictionary "el")
      (ispell-change-dictionary "en")))

  (defun prot/flyspell-dwim (&optional beg end)
    "Run `flyspell-region' on the active region, else toggle the
ispell dictionaries with `prot/ispell-toggle-dictionaries'."
    (interactive "r")
      (if (use-region-p)
          (flyspell-region beg end)

  :bind (("M-$" . prot/flyspell-dwim)
         ("C-M-$" . prot/ispell-toggle-dictionaries)
         :map flyspell-mode-map
         ("C-;" . nil)))

6.3.6 Flycheck (code linting)

This is a great tool for identifying errors or inconsistencies in programming syntax. I used it for my Modus themes (defined elsewhere in this document) to make the necessary checks for code quality, in preparation of their release as a MELPA package.

This package provides a broad range of customisation options, with many items targeting specific programming languages and/or style conventions. It seems very powerful! As these targeted operations require some more research, I leave everything to its default value and will be updating the package declaration over time.

(use-package flycheck
  :ensure t
  :commands flycheck-mode
  (setq flycheck-check-syntax-automatically
        '(save mode-enabled)))

Also offer a Flycheck indicator in the mode line.

(use-package flycheck-indicator
  :ensure t
  :after flycheck
  :hook (flycheck-mode . flycheck-indicator-mode))

There is also a built-in tool that covers Flycheck's niche, but I find its functionality somewhat more limited. As such I am defining it so that an autoload will be created for it (meaning that it will only be made available on demand).

(use-package flymake
  :commands flymake-mode) Flycheck package metadata

This one integrates with Flycheck to provide the necessary checks for code that is intended for use in MELPA. I just define the linter for packages as a standalone declaration, in case I wish to keep this without the flycheck interface.

(use-package package-lint
  :ensure t)

(use-package flycheck-package
  :ensure t
  :after (flycheck package-lint)

6.3.7 Eldoc (elisp live documentation feedback)

Displays information about the construct at point in the echo area. I find that I have no use for this, so I am disabling the mode for the time being.

(use-package eldoc
  (global-eldoc-mode -1))

6.3.8 Markdown support

I edit lots of Markdown files. This makes things easier.

(use-package markdown-mode
  :ensure t
  :mode ("\\.md\\'" . markdown-mode))

6.3.9 YAML support

This adds support for YAML files.

(use-package yaml-mode
  :ensure t
  :mode (("\\.yml\\'" . yaml-mode)
         ("\\.yaml\\'" . yaml-mode)))

6.3.10 Support for various config files

The following rules implement the appropriate syntax highlighting in various configuration files that I access.

The list will be expanded over time.

(use-package emacs
  :mode (("offlineimaprc" . conf-mode)
         ("sxhkdrc" . conf-mode)
         ("Xmodmap" . conf-xdefaults-mode)
         ("template" . shell-script-mode)
         ("\\.rasi\\'" . css-mode)))

6.3.11 Configure 'electric' behaviour

Emacs labels as "electric" any behaviour that involves contextual auto-insertion of characters. This is a summary of my settings:

  • Indent automatically.
  • If electric-pair-mode is enabled (which I might do manually), insert quotes and brackets in pairs. Only do so if there is no alphabetic character after the cursor.
  • The cryptic numbers in the pairs set, correspond to curly single and double quotes and these «». The contents of this set are always inserted in pairs, regardless of major mode.
    • To get those numbers, evaluate (string-to-char CHAR) where CHAR is the one you are interested in. For example, get the literal tab's character with (string-to-char "\t").
  • While inputting a pair, inserting the closing character will just skip over the existing one, rather than add a new one. So typing ( will insert () and then typing ) will just be the same as moving forward one character C-f.
  • Do not skip over whitespace when operating on pairs. Combined with the above point, this means that a new character will be inserted, rather than be skipped over. I find this better, because it prevents the point from jumping forward, plus it allows for more natural editing.
  • The whitespace characters are space (\s), tab (\t), and newline (\n).
  • The rest concern the conditions for transforming quotes into their curly equivalents. I keep this disabled, because curly quotes are distinct characters. It is difficult to search for them. Just note that on GNU/Linux you can type them directly by hitting the "compose" key and then an angled bracket (< or >) followed by a quote mark.
(use-package electric
  (setq electric-pair-inhibit-predicate'electric-pair-conservative-inhibit)
  (setq electric-pair-preserve-balance t)
  (setq electric-pair-pairs
        '((8216 . 8217)
          (8220 . 8221)
          (171 . 187)))
  (setq electric-pair-skip-self 'electric-pair-default-skip-self)
  (setq electric-pair-skip-whitespace nil)
  (setq electric-pair-skip-whitespace-chars
  (setq electric-quote-context-sensitive t)
  (setq electric-quote-paragraph t)
  (setq electric-quote-string nil)
  (setq electric-quote-replace-double t)
  :hook (after-init . (lambda ()
                        (electric-indent-mode 1)
                        (electric-pair-mode -1)
                        (electric-quote-mode -1))))

6.3.12 Parentheses

Configure the mode that highlights matching delimiters or parentheses. I consider this of utmost importance when working with languages such as elisp.

Summary of what these do:

  • Activate the mode.
  • Show the matching delimiter/parenthesis if on screen, else show nothing. It is possible to highlight the expression enclosed by the delimiters, by using either mixed or expression. The latter always highlights the entire balanced expression, while the former will only do so if the matching delimiter is off screen.
  • Highlight parentheses even if the point is in their vicinity. This means the beginning or end of the line, with space in between.
  • Do not highlight a match when the point is on the inside of the parenthesis.
(use-package paren
  (setq show-paren-style 'parenthesis)
  (setq show-paren-when-point-in-periphery t)
  (setq show-paren-when-point-inside-paren nil)
  :hook (after-init . show-paren-mode))

6.3.13 Tabs, indentation, and the TAB key

I believe tabs, in the sense of inserting the tab character, are best suited for indentation. While spaces are superior at precisely aligning text. However, I understand that elisp uses its own approach, which I do not want to interfere with. Also, Emacs tends to perform alignments by mixing tabs with spaces, which can actually lead to misalignments depending on certain variables such as the size of the tab. As such, I am disabling tabs by default.

If there ever is a need to use different settings in other modes, we can customise them via hooks. This is not an issue I have encountered yet and am therefore refraining from solving a problem that does not affect me.

(use-package emacs
  (setq-default tab-always-indent t)
  (setq-default tab-width 4)
  (setq-default indent-tabs-mode nil))

6.4 Registers

Registers are compartments that hold data of various sorts. They offer the means for advanced, highly-efficient workflows, especially when combined with keyboard macros.

Registers are called by a single character, which can be a letter (case-sensitive), number, or symbol. Each character can only contain a single register at a time.

To define a register, you call the appropriate command (see table below) and then specify the character you want to store that data at.

Key chord Command
C-x r n number-to-register
C-x r s copy-to-register (think "save string")
C-x r r copy-rectangle-to-register
C-x r SPC point-to-register
C-x r w window-configuration-to-register
C-x r f frameset-to-register (frames and their windows)
C-x r + increment-register (better used with numbers)
C-x r i insert-register (text, number, rectangle)
C-x r j jump-to-register (to point or window/frameset config)

Notes about some of the above:

  • Using point-to-register allows you to revisit a specific location in a buffer, but also reopen the file visited by that buffer in case the buffer is deleted.
  • Calling number-to-register without an argument will just store the number 0 to the register you specify. Whereas C-u 100 C-x r n will store 100. In practice, you often want to use the latter method.
  • Use increment-register to increment a number by one. Pass a numeric argument to increment by that amount instead. For example, to increment by five do C-u 5 C-x r + and then select the register you want to operate on. This only affects the value stored in the register. It does not also insert it in the buffer.
  • Number registers are particularly useful when you want to increment several numbers through a keyboard macro. You can record the motions you need, run increment-register as noted above followed by the standard insert-register. If, however, you just want to increment a single number through a keyboard macro, then just use the counter provided by that facility (refer to my video on easier kmacro counter from 2019-10-14).
  • The registers that store text as a string or a rectangle rely on the active region to capture the data. They are also great for keyboard macros where you cannot rely on yanking from the head of the kill ring (because, say, you are killing other things which push that value further down). Note though that increment-register has a different behaviour when applied to them, where it will append to the register instead (with an option to override the previous value).
  • While on the topic of appending to registers, I define several functions that change how the accumulation of text is supposed to happen. They introduce a space or line separator between the entries you {ap,pre}-pend to the register.
  • In my testing, I could never make window-configuration-to-register persist between sessions (see section on Emacs server and desktop). Whereas all other registers retain their values. So use this command to store window configurations that are otherwise transient in nature. For more permanent setups, rely on frameset-to-register which will produce a new frame (or more if you had) with all the windows in place. Remember that you can always go back to your previous window configuration without using registers, such as with the built-in winner-mode (see section on window history and directional motions).
  • While on the topics of storing registers across sessions, I find that sometimes I will collect too many registers that I do not really need any more. So prot/clear-registers just resets the list.
(use-package register
  :commands (prot/clear-registers
  ;;;;;; Use this if you need it
  ;;;; Define f5 as an alias for C-x r
  ;; (global-set-key (kbd "<f5>") (lookup-key global-map (kbd "C-x r")))

  (defun prot/clear-registers ()
    "Remove all saved registers."
    (setq register-alist nil))

  (defun prot/append-register-space-separator (start end)
    "Append region to register with space in between entries.

A prompt will ask for the register to operate on."
    (interactive "r")
    (let* ((prompt (register-read-with-preview
                    "Append to register with space separator: ")))
      (setq register-separator ?+)
      (set-register register-separator " ")
      (append-to-register prompt start end nil)))

  (defun prot/append-register-line-separator (start end)
    "Append region to register with an empty line in between entries.

A prompt will ask for the register to operate on."
    (interactive "r")
    (let* ((prompt (register-read-with-preview
                    "Append to register with line separator: ")))
      (setq register-separator ?+)
      (set-register register-separator "\n\n")
      (append-to-register prompt start end nil)))

  (defun prot/prepend-register-space-separator (start end)
    "Prepend region to register with space in between entries.

A prompt will ask for the register to operate on."
    (interactive "r")
    (let* ((prompt (register-read-with-preview
                    "Prepend to register with space separator: ")))
      (setq register-separator ?+)
      (set-register register-separator " ")
      (prepend-to-register prompt start end nil)))

  (defun prot/prepend-register-line-separator (start end)
    "Prepend region to register with an empty line in between entries.

A prompt will ask for the register to operate on."
    (interactive "r")
    (let* ((prompt (register-read-with-preview
                    "Prepend to register with line separator: ")))
      (setq register-separator ?+)
      (set-register register-separator "\n\n")
      (prepend-to-register prompt start end nil))))

6.5 Custom movements and motions

I generally rely on the default keys to move around (plus my Super-KEY additions to economise on some repetitive tasks). There are, however, some motions that are rather cumbersome or too specialised. While there are some commands that are not available at all. For those cases, I rely on custom functions.

6.5.1 Mark by semantic unit (expand-region)

The expand-region library offers the means to mark syntactic elements by semantic unit: word, symbol, string, balanced expression… The expansion is incremental, from the smallest to the largest match, with each increment performed by = following the initial invocation of the command (decrement with - or reset with 0) or by just repeatedly hitting C-=.

There are lost of specialised functions bundled up together with this package. Rather than bind each one to a key, I prefer to keep things simple: er/expand-region only ever needs a couple extra calls to match compound units. The few exceptions are for commands I use all the time.

Note though that this library is complementary to existing commands (which can be ignored or altogether superseded). Here is a quick reference:

Function Key binding
mark-paragraph M-h
mark-sexp C-M-SPC
mark-whole-buffer C-x h
mark-word M-@
(use-package expand-region
  :ensure t
  :pin gnu                              ; Prefer ELPA version
  (setq expand-region-smart-cursor t)
  :bind (("C-=" . er/expand-region)
         ("C-M-=" . er/mark-outside-pairs)
         ("C-+" . er/mark-symbol)))

6.5.2 Collection of unpackaged commands or tweaks

These are small functions that facilitate my day-to-day work with Emacs. They are written by me, unless otherwise noted.

Copy the current line
Just place the entire line in the kill ring. Do not be smart about it.
Count words in buffer
By default, the binding M-= will count the lines, words, characters in the region. I never use that. What I do use is the equivalent for the whole buffer.
Delete pair forward/backward
The built-in delete-pair will remove a pair of characters from the point onward. It uses the character after point to determine the matching character. I bind that to C-delete as it is conceptually close to regular Delete. Then I bind an equivalent backward motion to C-backspace so that it is similar to how the backward deletion of words works (M-backspace).
Insert pairs
These are several functions that allow for manual insertion of various common delimiters I use. The idea is to offer the means of quickly wrapping a word/symbol/region in those characters without having to always run a minor mode that "intelligently" decides when to insert pairs. The basic pattern for these keybindings is derived from the default M-( which runs insert-parentheses: the basis of all these commands. Note also that M-` shadows the default keys for tmm-menubar, which is a command I am 100% sure I will never use.
Faster multiline move
Move up or down by 15 lines at a time. This is the equivalent of C-u 15 C-n or C-u 15 C-p.
Kill this buffer
A faster way of killing the focused buffer, without the need for confirming which buffer to kill. Unsaved files will still ask for confirmation though, which is exactly as it should be. Bound to s-k.
Kill to the begging of line
Just remove everything from the point till the beginning of the line. Do not try anything fancy like adjusting indentation or removing the line break.
New line above or below
Create a new line above or below the current one and place the point at its beginning. Does not matter where the point is on the current line. Does not try to account for any indentation rules.
Rename current buffer
Change the file name being visited by the current buffer. This updates both the name of the buffer and the file system path. I extracted this command from the Crux package.
Shrink whitespace
By default, M-SPC will reduce multiple spaces into a single one, while M-\ will remove all space at once. Then there is C-x C-o which is the inverse of C-o. For the first two of the aforementioned, I use cycle-spacing: a single invocation will leave one space; a second removes all space; while a third consecutive call restores the original state. Also, since I have no use for the default function bound to M-o I make it an alias for C-x C-o.
Transpose characters
Tweak the way the original command works, so that it always transposes the two characters before point. This will no longer have the effect of moving the character forward following repeated invocations of the command. Just a toggle to quickly fix the last typo.
Transpose or swap lines
Behave as the original transpose-lines, but also be aware of the active region in which case swap the line at point (region end) with the line at mark (region beginning).
Transpose or swap paragraphs
A wrapper around the original transpose-paragraphs that fulfils my expectations: if region is active, swap paragraph at mark (region beginning) with one at point (region end), otherwise transpose current paragraph with the one after it (drag paragraph downward/forward).
Transpose or swap sentences
Same principle as above. When region is active it exchanges the sentences at either end of it, otherwise is drags the sentence forward. The added effect here is that if point is at the end of the paragraph, where no further 'dragging' can occur, it transposes the sentence at point with the one before it.
Transpose or swap words
Same as with the other "swap" commands. In addition, this alters transpose-words while at the end of line where it will only transpose the last two words before the point. It thus avoids transposing words across lines or paragraphs.
Unfill text DWIM
With M-q we can break a long line into a block that ends each line at the fill-column (I configure Emacs to do this automatically, where appropriate, but often do it manually). With M-^ we can join the line at point with the one above. But there seems to be no way of doing this for a block of text. So I assign the following function to M-Q (must also hold down Shift).
Yank over current line or region
Replace the contents of the line at point (or the active region) with the most recent item from the kill ring.
(use-package emacs
  (defun prot/copy-line ()
    "Copies the entirety of the current line."
    (copy-region-as-kill (point-at-bol) (point-at-eol))
    (message "Current line copied"))

  (defun prot/delete-pair-backward ()
    "Delete pair of characters before point.

Use the character right before point as a reference on what to
match for deletion."
    (delete-pair -1))

  (defun prot/insert-double-quotes (&optional arg)
    "Insert a pair of double quotes or wrap ARG with them."
    (interactive "P")
    (insert-pair arg ?\" ?\"))

  (defun prot/insert-double-smart-quotes (&optional arg)
    "Insert a pair of double smart quotes or wrap ARG with them."
    (interactive "P")
    (insert-pair arg ?\“ ?\”))

  (defun prot/insert-single-smart-quotes (&optional arg)
    "Insert a pair of single smart quotes or wrap ARG with them."
    (interactive "P")
    (insert-pair arg ?\‘ ?\’))

  (defun prot/insert-elisp-quotes (&optional arg)
    "Insert a pair of elisp symbol quotes or wrap ARG with them."
    (interactive "P")
    (insert-pair arg ?\` ?\'))

  (defun prot/multi-line-next ()
    "Moves point 15 lines down."
    (forward-line 15))

  (defun prot/multi-line-prev ()
    "Moves point 15 lines up."
    (forward-line -15))

  (defun prot/kill-line-backward ()
    "Kill from point to the beginning of the line."
    (kill-line 0))

  (defun prot/new-line-below ()
    "Create a new line below the current one.  Move the point to
the absolute beginning.  Also see `prot/new-line-above'."

  (defun prot/new-line-above ()
    "Create a new line above the current one.  Move the point to
the absolute beginning.  Also see `prot/new-line-below'."
    (forward-line -1))

  (defun contrib/rename-file-and-buffer ()
    "Rename current buffer and if the buffer is visiting a file, rename it too."
    (let ((filename (buffer-file-name)))
      (if (not (and filename (file-exists-p filename)))
          (rename-buffer (read-from-minibuffer "New name: " (buffer-name)))
        (let* ((new-name (read-from-minibuffer "New name: " filename))
               (containing-dir (file-name-directory new-name)))
          (make-directory containing-dir t)
           ((vc-backend filename) (vc-rename-file filename new-name))
            (rename-file filename new-name t)
            (set-visited-file-name new-name t t)))))))

  (defun prot/transpose-chars ()
    "Always transposes the two characters before point.  There is
no 'dragging' the character forward.  This is the behaviour of
`transpose-chars' when point is at end-of-line."
    (transpose-chars -1)

  (defun prot/transpose-or-swap-lines (arg)
    "If region is active, swap the line at mark (region
beginning) with the one at point (region end).  This leverages a
facet of the built-in `transpose-lines'.  Otherwise transpose the
current line with the one before it ('drag' line downward)."
    (interactive "p")
    (if (use-region-p)
        (transpose-lines 0)
      (transpose-lines arg)))

  (defun prot/transpose-or-swap-paragraphs (arg)
    "If region is active, swap the paragraph at mark (region
beginning) with the one at point (region end).  This leverages a
facet of the built-in `transpose-paragraphs'.  Otherwise
transpose the current paragraph with the one after it ('drag'
paragraph downward)."
    (interactive "p")
    (if (use-region-p)
        (transpose-paragraphs 0)
      (transpose-paragraphs arg)))

  (defun prot/transpose-or-swap-sentences (arg)
    "If region is active, swap the sentence at mark (region
beginning) with the one at point (region end).  This leverages a
facet of the built-in `transpose-sentences'.  Otherwise transpose
the sentence before point with the one after it ('drag' sentence
forward/downward).  Also `fill-paragraph' afterwards.

Note that, by default, sentences are demarcated by two spaces."
    (interactive "p")
    (if (use-region-p)
        (transpose-sentences 0)
      (transpose-sentences arg))

  (defun prot/transpose-or-swap-words (arg)
    "If region is active, swap the word at mark (region
beginning) with the one at point (region end).

Otherwise, and while inside a sentence, this behaves as the
built-in `transpose-words', dragging forward the word behind the
point.  The difference lies in its behaviour at the end of a
line, where it will always transpose the word at point with the
one behind it (effectively the last two words).

This addresses two patterns of behaviour I dislike in the
original command:

1. When a line follows, `M-t' will transpose the last word of the
line at point with the first word of the line below.

2. While at the end of the line, `M-t' will not transpose the
last two words, but will instead move point one word backward.
To actually transpose the last two words, you need to invoke the
command twice."
    (interactive "p")
    (if (use-region-p)
        (transpose-words 0)
      (if (eq (point) (point-at-eol))
            (backward-word 1)
            (transpose-words 1)
            (forward-char 1))
        (transpose-words arg))))

  (defun prot/unfill-region-or-paragraph (&optional region)
    "Join all lines in a region, if active, while respecting any
empty lines (so multiple paragraphs are not joined, just
unfilled).  If no region is active, operate on the paragraph.
The idea is to produce the opposite effect of both
`fill-paragraph' and `fill-region'."
    (let ((fill-column most-positive-fixnum))
      (if (use-region-p)
          (fill-region (region-beginning) (region-end))
        (fill-paragraph nil region))))

  (defun prot/yank-replace-line-or-region ()
    "Replace the line at point with the contents of the last
stretch of killed text.  If the region is active, operate over it
instead.  This command can then be followed by the standard
`yank-pop' (default is bound to M-y)."
    (if (use-region-p)
          (delete-region (region-beginning) (region-end))
      (delete-region (point-at-bol) (point-at-eol))

  :bind (("<C-f2>" . contrib/rename-file-and-buffer)
         ("C-S-w" . prot/copy-line)
         ("M-=" . count-words)
         ("<C-delete>" . delete-pair)
         ("<C-backspace>" . prot/delete-pair-backward)
         ("M-\"" . prot/insert-double-quotes)
         ("C-M-\"" . prot/insert-double-smart-quotes)
         ("C-M-'" . prot/insert-single-smart-quotes)
         ("M-`" . prot/insert-elisp-quotes)
         ("s-k" . kill-this-buffer)
         ("M-k" . prot/kill-line-backward)
         ("C-S-n" . prot/multi-line-next)
         ("C-S-p" . prot/multi-line-prev)
         ("<C-return>" . prot/new-line-below)
         ("<C-S-return>" . prot/new-line-above)
         ("M-SPC" . cycle-spacing)
         ("M-o" . delete-blank-lines)
         ("C-t" . prot/transpose-chars)
         ("C-x C-t" . prot/transpose-or-swap-lines)
         ("C-S-t" . prot/transpose-or-swap-paragraphs)
         ("C-x M-t" . prot/transpose-or-swap-sentences)
         ("M-t" . prot/transpose-or-swap-words)
         ("M-Q" . prot/unfill-region-or-paragraph)
         ("C-S-y" . prot/yank-replace-line-or-region)))

6.5.3 Go to last change

I could not find any built-in method of reliably moving back to the last change. Using the mark ring is always an option, but does not fill the exact same niche.

The C-z binding is disabled in the opening sections of this document. It minimises the Emacs GUI. A complete waste of an extremely valuable key binding!

(use-package goto-last-change
  :ensure t
  :bind ("C-z" . goto-last-change))

6.6 Cursor and mouse settings

6.6.1 Cursor appearance and tweaks

My cursor for the current window is a box character that blinks. Other windows use a vertical bar that is 2 pixels wide.

The default blink settings are close to my expectations, though I do apply some small tweaks to the interval between blinks and the delay for the initial blinking. Where I differ substantially from the defaults is the number of blinks before switching to a non-blinking state. The original value of blink-cursor-blinks is just 10 blinks, which can be fairly short in a number of scenaria.

(use-package emacs
  (setq-default cursor-type 'box)
  (setq-default cursor-in-non-selected-windows '(bar . 2))
  (setq-default blink-cursor-blinks 50)
  (setq-default blink-cursor-interval 0.75)
  (setq-default blink-cursor-delay 0.2)
  :hook (after-init . blink-cursor-mode))

6.6.2 Beacon mode (highlight cursor position)

This package will light a beam where the cursor is. A nice way of quickly discovering your current position in the current window.

There is a minor mode with several customisation options, in case you want to have this functionality to be readily available. I generally do not need it to always be on, so I just bind a key for calling the command manually and only tweak the visuals of the beam effect.

For the way the beacon-color is determined through a custom hook, refer to the section on the Modus themes (my very accessible themes).

(use-package beacon
  :ensure t
  (setq beacon-blink-delay 0.1)
  (setq beacon-blink-duration 0.25)
  (setq beacon-size 25)

  (defun prot/beacon-color ()
    "Set the value of `beacon-color' depending on theme.

This is meant to be called from `prot/modus-themes-toggle-hook'."
    (cond ((eq (car custom-enabled-themes) 'modus-operandi)
           (setq beacon-color "#b60000"))
          ((eq (car custom-enabled-themes) 'modus-vivendi)
           (setq beacon-color "#fb6859"))))

  (beacon-mode -1)
  :bind ("<s-escape>" . beacon-blink)
  :hook (prot/modus-themes-toggle . prot/beacon-color))

6.6.3 Mouse wheel behaviour

The value of mouse-wheel-scroll-amount means the following:

  • By default scroll by one line.
  • Hold down Shift to do so by five lines.
  • Hold down Meta to scroll half a screen.
  • Hold down Control to adjust the size of the text. This is added in Emacs 27.

By enabling mouse-drag-copy-region we automatically place the mouse selection to the kill ring. This is the same behaviour as terminal emulators that place the selection to the clipboard (or the primary selection).

The other options in short:

  • Hide mouse pointer while typing.
  • Enable mouse scroll.
  • Faster wheel movement means faster scroll.
  • Scroll window under mouse pointer regardless of whether it is the current one or not.
(use-package mouse
  ;; In Emacs 27, use Control + mouse wheel to scale text.
  (setq mouse-wheel-scroll-amount
          ((shift) . 5)
          ((meta) . 0.5)
          ((control) . text-scale)))
  (setq mouse-drag-copy-region t)
  (setq make-pointer-invisible t)
  (setq mouse-wheel-progressive-speed t)
  (setq mouse-wheel-follow-mouse t)
  :hook (after-init . mouse-wheel-mode))

6.6.4 Scrolling behaviour

Page scrolling should keep the point at the same visual position, rather than force it to the top or bottom of the viewport. This eliminates the friction of guessing where the point has warped to.

As for per-line scrolling, I dislike the default behaviour of visually re-centring the point. With the following, it will stay at the top/bottom of the screen while moving in that direction (use C-l to reposition it). This does not result in more manual interventions to recenter text, because of the above.

(use-package emacs
  (setq scroll-preserve-screen-position t)
  (setq scroll-conservatively 1)        ; affects `scroll-step'
  (setq scroll-margin 0))

6.6.5 Delete selection

This is a very helpful mode. It kills the marked region when inserting directly to it. It also has checks to ensure that yanking over a selected region will not insert itself when mouse-drag-copy-region is in effect (see the section on the mouse wheel behaviour).

(use-package delsel
  :hook (after-init . delete-selection-mode))

Pro tip: On Emacs 27.1 you can create a rectangular region by holding down Ctrl and Meta while dragging the mouse with the left click pressed.

6.6.6 Tool tips

These settings control how tool tips are to be handled when hovering the mouse over an actionable item:

  • I just want to make sure that the GTK theme is not used for those: I prefer the generic display which follows my current theme's styles.
  • The delay is slightly reduced for the initial pop-up, while it has been increased for immediate pop-ups thereafter.
(use-package tooltip
  (setq tooltip-delay 0.5)
  (setq tooltip-short-delay 0.5)
  (setq x-gtk-use-system-tooltips nil)
  :hook (after-init . tooltip-mode))

6.7 Conveniences and minor extras

6.7.1 Auto revert mode

This mode ensures that the buffer is updated whenever the file changes. A change can happen externally or by some other tool inside of Emacs (e.g. kill a Magit diff).

(use-package autorevert
  (setq auto-revert-verbose t)
  :hook (after-init . global-auto-revert-mode))

6.7.2 Preserve contents of system clipboard

Say you copied a link from your web browser, then switched to Emacs to paste it somewhere. Before you do that, you notice something you want to kill. Doing that will place the last kill to the clipboard, thus overriding the thing you copied earlier. We can have a kill ring solution to this with the following:

(use-package emacs
  (setq save-interprogram-paste-before-kill t))

Now the contents of the clipboard are stored in the kill ring and can be retrieved from there (e.g. with M-y).

6.7.3 Delete trailing whitespace

This always creates unnecessary diffs in git. Just delete it upon saving.

(use-package emacs
  :hook (before-save . delete-trailing-whitespace))

6.7.4 Generic feedback

The common thread of these options is the feedback they provide us with or simplify common tasks so that their feedback does not cause friction:

  • Show the current buffer's name as the frame's title. This only affects window managers that have window decorations. If you do not know what that means, then you are most likely using an environment where frame titles are already visible.
  • Faster feedback for key chords (keys appear in the echo area).
  • Allow inputting Greek while preserving Emacs keys. Toggle with C-\.
  • Ignore visual or audible bells. Emacs has more appropriate ways of providing error/warning messages or hints that something is not producing the desired results (e.g. a failed isearch will return no results, while the failed match will be styled accordingly in the echo area). By the way, use C-h e to bring up the log with the echo area's messages.
  • Answer with just the initials when dealing with "yes/no" questions.
  • Enable actions for narrowing the buffer, region {up,down}casing (all caps or no caps), dired single-buffer navigation (bound to a). Disable overwrite-mode.
(use-package emacs
  (setq frame-title-format '("%b"))
  (setq echo-keystrokes 0.25)
  (setq default-input-method "greek")
  (setq ring-bell-function 'ignore)

  (defalias 'yes-or-no-p 'y-or-n-p)
  (put 'narrow-to-region 'disabled nil)
  (put 'upcase-region 'disabled nil)
  (put 'downcase-region 'disabled nil)
  (put 'dired-find-alternate-file 'disabled nil)
  (put 'overwrite-mode 'disabled t))

6.7.5 Altered zap and easier repeats

I seldom use the functionality related to this section, but when I do I prefer it to work the way I expect. zap-up-to-char will delete everything from point up to the character you provide it with. Think of how you may want to delete a file name but keep its file type extension.

The repeat command is bound by default to C-x z. I make it so that subsequent repetitions require only hitting another z. In practice though, you should not bother with this. Let keyboard macros handle that task.

Pro tip: to make a keyboard macro out of your most recent commands, use C-x C-k l which calls kmacro-edit-lossage. The list is editable, so remove anything that is not required and then save what is left. The result is stored as the latest keyboard macro (and you also have the power to cycle through kmacros, store them in specific keys, etc.).

Moving on to the mark, practically every Emacs motion that operates on a portion of text will set the mark automatically. You can also do it manually with C-SPC (hit it twice if you do not wish to activate the region). It is then possible to cycle through the marks in reverse order by passing a prefix argument C-u C-SPC. With the evaluation of set-mark-command-repeat-pop as t we can continue cycling by repeated presses of C-SPC. Again though, this is not the type of functionality I rely on: for more deliberate actions of this sort, consider Emacs' notion of "registers".

(use-package emacs
  (setq repeat-on-final-keystroke t)
  (setq set-mark-command-repeat-pop t)
  :bind ("M-z" . zap-up-to-char))

6.7.6 Package lists

With this I just want to enable line highlighting when browsing the list of packages. I generally use hl-line-mode on all interfaces where the current line is more important than the exact column of the point.

(use-package package
  :commands (list-packages
  :hook (package-menu-mode . hl-line-mode))

7 History and state

This section contains configurations for packages that are dedicated to the task of recording the state of various Emacs tools, such as the history of the minibuffer or the list of recently-visited files.

In practice, these are some of the most useful configurations one can make, as lots of functions depend on them. For example, a record of the minibuffer's history of inputs allows the completion framework to guess the most likely course of action. Typing M-x g gives me gnus as the first possible option, which is exactly what I want.

7.1 Emacs server and desktop

The following uses the first running process of Emacs as the one others may connect to. This means that calling emacsclient (with or without --create-frame), will share the same buffer list and data as the original running process, aka "the server". The server persists for as long as there is an Emacs frame attached to it.

(use-package server
  :hook (after-init . server-start))

With some exceptions aside, I only ever use Emacs in a single frame. What I find more useful is the ability to save the state I was in: the name the of buffers, the cursor's position in each of them, the recent file list, the minibuffer history, my stored registers.

The state of the available buffers and the values of each register are called the "desktop" (for the other items see the following sections on recording various types of history).

Preserving the "desktop" saves me from any possible crash or when I need to close Emacs and re-launch it later (my hardware is limited, so I do not keep it running while I am away).

Overview of my settings:

  • Enable the mode that saves the "desktop", instructing it to load a small number of buffers at launch (desktop-restore-eager). The remainder of the buffer list will be loaded lazily.
  • Now we must tell it where to store the files it generates and how often it should save. Concerning the latter, the default is to store the state every time it changes. I find that a bit too much, so I set a timeout of five minutes of idleness.
  • Note the desktop-load-locked-desktop. By default, Emacs locks the desktop file while it runs. The lock is removed upon exiting. This is a safety mechanism. There are two cases where the lock can create issues:
    • Emacs has crashed, meaning that it exited abruptly and was not able to unlock the desktop. Upon re-launch Emacs will prompt you whether to load the locked file. You normally want to answer affirmatively.
    • Emacs runs in daemon mode, where it does not ask questions upon loading. In this case the lock is ignored.
    • Because I am only affected by the former, I choose to disable the prompt and just load the thing directly. Otherwise, I would set it to nil.
  • Do not restore frame configurations. If I need to store one of those, I use registers, specifically C-x r f (see section on Registers).
  • Ask what to do in case the session has a newer file that the one it initially started out with (e.g. when a new frame runs in parallel to the older one).
(use-package desktop
  (setq desktop-auto-save-timeout 300)
  (setq desktop-dirname "~/.emacs.d/")
  (setq desktop-base-file-name "desktop")
  (setq desktop-files-not-to-save nil)
  (setq desktop-globals-to-clear nil)
  (setq desktop-load-locked-desktop t)
  (setq desktop-missing-file-warning t)
  (setq desktop-restore-eager 3)
  (setq desktop-restore-frames nil)
  (setq desktop-save 'ask-if-new)
  (desktop-save-mode 1))

7.2 Record various types of history

7.2.1 Recentf (recent files and directories)

This is a built-in mode that keeps track of the files you have opened, allowing you go back to them faster. It can also integrate with a completion framework to populate their "virtual buffers" list.

A few words about the variables I configure:

  • Enable the mode and define the file it should use to store the list of files.
  • Allow only 10 items in the menu. This is used by the menu bar, which I disable by default.
  • Store up to 200 items at a time. The number is arbitrary but seems good enough for me to (a) find common items quickly, (b) do not keep track of everything I ever access.
  • Do not prepend a number to the first ten files that appear in the dedicated recentf buffer (accessible via recentf-open-files).

Now some notes on my extensions:

  • The functions whose name starts with "rjs" are intended to address a limitation in the original package that does not keep track of file name changes. With these we make sure that the list is updated any time a file is moved/renamed. My sole contribution to these functions is to append the recentf-cleanup function where appropriate, to ensure that only the new name is tracked, while the old is discarded.
  • The function that includes Dired buffers to the list, is extracted from the recentf-ext file on the Emacs Wiki. I use this in tandem with my completion framework's virtual buffers. This practically eliminates whatever need for a dedicated command to display recently-accessed directories (dired buffers).
(use-package recentf
  (setq recentf-save-file "~/.emacs.d/recentf")
  (setq recentf-max-menu-items 10)
  (setq recentf-max-saved-items 200)
  (setq recentf-show-file-shortcuts-flag nil)

  ;; rename entries in recentf when moving files in dired
  (defun rjs/recentf-rename-directory (oldname newname)
    ;; oldname, newname and all entries of recentf-list should already
    ;; be absolute and normalised so I think this can just test whether
    ;; oldname is a prefix of the element.
    (setq recentf-list
          (mapcar (lambda (name)
                    (if (string-prefix-p oldname name)
                        (concat newname (substring name (length oldname)))

  (defun rjs/recentf-rename-file (oldname newname)
    (setq recentf-list
          (mapcar (lambda (name)
                    (if (string-equal name oldname)

  (defun rjs/recentf-rename-notify (oldname newname &rest args)
    (if (file-directory-p newname)
        (rjs/recentf-rename-directory oldname newname)
      (rjs/recentf-rename-file oldname newname)))

  (advice-add 'dired-rename-file :after #'rjs/recentf-rename-notify)

  (defun contrib/recentf-add-dired-directory ()
    "Include Dired buffers in the `recentf' list.  Particularly
useful when combined with a completion framework's ability to
display virtual buffers."
    (when (and (stringp dired-directory)
               (equal "" (file-name-nondirectory dired-directory)))
      (recentf-add-file dired-directory)))

  :hook ((after-init . recentf-mode)
         (dired-mode . contrib/recentf-add-dired-directory)))

7.2.2 Minibuffer history

Keeps a record of actions involving the minibuffer. This is of paramount importance to a fast and efficient workflow involving any completion framework that leverages the built-in mechanisms.

Emacs will remember your input and choices and will surface the desired results towards the top as the most likely candidates. Make sure to also check my configurations for the minibuffer and icomplete.

I set the length to a fairly high number, while I make sure that duplicate entries remain in tact. The assumption is that duplicate entries increase the likelihood of returning the candidate I am searching or.

(use-package savehist
  (setq savehist-file "~/.emacs.d/savehist")
  (setq history-length 30000)
  (setq history-delete-duplicates nil)
  (setq savehist-save-minibuffer-history t)
  (savehist-mode 1))

7.2.3 Record cursor position

Just remember where the point is in any given file. This can often be a subtle reminder of what you were doing the last time you visited that file, allowing you to pick up from there.

(use-package saveplace
  (setq save-place-file "~/.emacs.d/saveplace")
  (setq save-place-forget-unreadable-files t)
  (save-place-mode 1))

7.2.4 Backups

And here are some settings pertaining to backups. I rarely need those, but I prefer to be safe in the knowledge that if something goes awry there is something to fall back to.

(use-package emacs
  (setq backup-directory-alist
        '(("." . "~/.emacs.d/backup/")))
  (setq backup-by-copying t)
  (setq version-control t)
  (setq delete-old-versions t)
  (setq kept-new-versions 6)
  (setq kept-old-versions 2)
  (setq create-lockfiles nil))

8 Important configurations that I stopped using

As my understanding of Emacs improves, I critically assess the utility of tools I once used. What is not needed is promptly removed. However, there are some cases where the deprecation of a package is basely solely on subjective criteria: the tools are still good, it just happens that I discovered something I like more.

Furthermore, there may be packages I once demonstrated in a video of mine, where I added my own extensions or whatnot and which people found useful.

Those are all stored in this section.

8.1 DEPRECATED Ivy/Counsel/Swiper plus filtering and scoring

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

This is a suite of tools that enhance several aspects of the Emacs experience. Basically we have:

  • ivy is the mechanism that handles all selection lists, narrowing them down using a variety of possible builders (regular expressions of flexible matching). It also provides a base interface for any function that needs to receive input based on a list of candidates.
  • counsel provides a superset of functions for navigating the file system, switching buffers, etc. that expand on the basic features supported by Ivy. For instance, switching buffers with Counsel offers a preview of their contents in the window, whereas regular Ivy does not.
  • swiper is a tool for performing searches, powered by Ivy, all while presenting a preview of the results.

8.1.1 DEPRECATED Configurations for Ivy

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

A few highlights of my configurations in the subsequent code block:

  • ivy-height-alist governs the maximum width of the Ivy window to 1/4 of the viewport. I prefer this over an absolute number as I work on monitors with varying dimensions (though note that ivy-posframe will override it, if enabled).
  • ivy-virtual-buffers populates buffer-switching lists with items from the recentf utility. In practice, a recently killed buffer can still be accessed from {ivy,counsel}-switch-buffer as if the kill had never occurred.
  • ivy-re-builders-list allows us to specify the algorithm for matching candidates. Unless declared otherwise, I am using regexp matching by default.
  • ivy-initial-inputs-alist adds some initial input to the commands we specify. I define it to prepend a caret sign (^) by default, unless explicitly stated not to include anything.
  • ivy-use-selectable-prompt solves the problem of trying to create a new file system path that shares a common name with an existing item. Press C-p and proceed without further conflicts.
  • The various ivy-set-occur are meant to specify a function for producing an appropriate buffer when running ivy-occur (see table right below).

And here are some 'hidden' key bindings for making the most out of Ivy (find more in the official manual).

Key Function Description
M-o ivy-dispatching-done Show actions for current match.
C-c C-o ivy-occur Place the list in a standalone buffer.
C-M-m ivy-call Run command, keep minibuffer open.
M-i ivy-insert-current Insert match in the prompt.
M-j ivy-yank-word Put word at point in the minibuffer prompt.
S-SPC ivy-restrict-to-matches Restrict list to prompt (and search anew).
C-SPC ivy-restrict-to-matches My alias for the above.

Adding to the table above, you can always use the universal M-n and M-p to cycle through the history of entries.

With those granted, make sure to inspect the entirety of my dotemacs' section on Selection candidates and search methods, as the following package declaration is but a piece of a greater whole.

(use-package ivy
  :disabled                             ; switched to `icomplete'
  :ensure t
  (setq ivy-count-format "(%d/%d) ")
  (setq ivy-height-alist '((t lambda (_caller) (/ (window-height) 4))))
  (setq ivy-use-virtual-buffers t)
  (setq ivy-wrap nil)
  (setq ivy-re-builders-alist
        '((counsel-M-x . ivy--regex-fuzzy)
          (ivy-switch-buffer . ivy--regex-fuzzy)
          (ivy-switch-buffer-other-window . ivy--regex-fuzzy)
          (counsel-rg . ivy--regex-or-literal)
          (t . ivy--regex-plus)))
  (setq ivy-display-style 'fancy)
  (setq ivy-use-selectable-prompt t)
  (setq ivy-fixed-height-minibuffer nil)
  (setq ivy-initial-inputs-alist
        '((counsel-M-x . "^")
          (ivy-switch-buffer . "^")
          (ivy-switch-buffer-other-window . "^")
          (counsel-describe-function . "^")
          (counsel-describe-variable . "^")
          (t . "")))

  (ivy-set-occur 'counsel-fzf 'counsel-fzf-occur)
  (ivy-set-occur 'counsel-rg 'counsel-ag-occur)
  (ivy-set-occur 'ivy-switch-buffer 'ivy-switch-buffer-occur)
  (ivy-set-occur 'swiper 'swiper-occur)
  (ivy-set-occur 'swiper-isearch 'swiper-occur)
  (ivy-set-occur 'swiper-multi 'counsel-ag-occur)
  :hook ((after-init . ivy-mode)
         (ivy-occur-mode . hl-line-mode))
  :bind (("<s-up>" . ivy-push-view)
         ("<s-down>" . ivy-switch-view)
         ("C-S-r" . ivy-resume)
         :map ivy-occur-mode-map
         ("f" . forward-char)
         ("b" . backward-char)
         ("n" . ivy-occur-next-line)
         ("p" . ivy-occur-previous-line)
         ("<C-return>" . ivy-occur-press)))

8.1.2 DEPRECATED Prescient (sort, filter results)

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

This tool provides a filtering and scoring system that can interface with Ivy. It is a replacement for amx.

Filtering concerns the way matches are determined. It is possible to select candidates by applying the search terms in a number of ways, such as a literal interpretation of the character string, a regular expression, a set of ordered wildcards (fuzzy match), or an initialism. The filters can be applied on a per function basis, though I that breaks the way Ivy highlights things.

The scoring system is based on the frequency and recency of commands. This is extremely valuable, as it will always surface to the top the commands you most likely need. Running M-x is now akin to starting a key chord chain (for example, M-x b will give me bongo as my first match, which is exactly what I need). It eliminates the need for increasingly arcane key bindings—use keys only for the most frequently-used commands.

The value of ivy-prescient-sort-commands defines functions that are exempt from all the sorting operations performed by this tool. I think that, at the very least, swiper should always be excluded from any kind of sorting mechanism, because it already orders its results based on the line number. We should not break that expectation. All other commands are just a matter of preference, where I simply find the generic sorting to offer a better first impression (does not really matter, since I will type something anyhow).

(use-package prescient
  :disabled                             ; switched to `icomplete'
  :ensure t
  (setq prescient-history-length 200)
  (setq prescient-save-file "~/.emacs.d/prescient-items")
  (setq prescient-filter-method '(literal regexp))
  (prescient-persist-mode 1))

(use-package ivy-prescient
  :disabled                             ; switched to `icomplete'
  :ensure t
  :after (prescient ivy)
  (setq ivy-prescient-sort-commands
        '(:not counsel-grep
  (setq ivy-prescient-retain-classic-highlighting t)
  (setq ivy-prescient-enable-filtering nil)
  (setq ivy-prescient-enable-sorting t)
  (ivy-prescient-mode 1))

8.1.3 DEPRECATED Counsel configurations and key bindings

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

A few things to consider about the settings in this sub-section:

  • With regard to key bindings, notice that Counsel's implementation for switching buffers will preview the currently matched item. This is particularly distracting when running it for the current window. For that case I use the generic Ivy method. I am okay with Counsel's approach when operating on the other window.
  • As for counsel-yank-pop-separator, its value is a series of em dashes with a newline character at either end. This creates a nice separator line when browsing the kill ring (counsel-yank-pop).
  • The function counsel-rg provides an interface to an external program called ripgrep. This is a great alternative to grep. For me the main selling point is its improved speed. The key chord for it is similar to the built-in occur.
  • The key chord for counsel-git-grep is also inspired by occur. This one will perform a search in the current git repository.
  • I have a few custom functions for finding files using a fluid workflow from fzf to ripgrep (and vice versa). Better check my video on Fuzzy search with “Ivy actions” for FZF and RIPGREP (2019-12-15).
  • For the prot/counsel-fzf-ace-window function, I recommend you refer to my package declaration for ace-window, in order to see what commands I want to use.

Also make sure to study all the other package declarations in the Selection candidates and search methods section, to appreciate their interplay and the full extent of my customisations.

(use-package counsel
  :disabled                             ; switched to `icomplete'
  :ensure t
  :after ivy
  (setq counsel-yank-pop-preselect-last t)
  (setq counsel-yank-pop-separator "\n—————————\n")
  (setq counsel-rg-base-command
        "rg -SHn --no-heading --color never --no-follow --hidden %s")
  (setq counsel-find-file-occur-cmd; TODO Simplify this
        "ls -a | grep -i -E '%s' | tr '\\n' '\\0' | xargs -0 ls -d --group-directories-first")

  (defun prot/counsel-fzf-rg-files (&optional input dir)
    "Run `fzf' in tandem with `ripgrep' to find files in the
present directory.  If invoked from inside a version-controlled
repository, then the corresponding root is used instead."
    (let* ((process-environment
            (cons (concat "FZF_DEFAULT_COMMAND=rg -Sn --color never --files --no-follow --hidden")
           (vc (vc-root-dir)))
      (if dir
          (counsel-fzf input dir)
        (if (eq vc nil)
            (counsel-fzf input default-directory)
          (counsel-fzf input vc)))))

  (defun prot/counsel-fzf-dir (arg)
    "Specify root directory for `counsel-fzf'."
    (prot/counsel-fzf-rg-files ivy-text
                                (concat (car (split-string counsel-fzf-cmd))
                                        " in directory: "))))

  (defun prot/counsel-rg-dir (arg)
    "Specify root directory for `counsel-rg'."
    (let ((current-prefix-arg '(4)))
      (counsel-rg ivy-text nil "")))

  ;; TODO generalise for all relevant file/buffer counsel-*?
  (defun prot/counsel-fzf-ace-window (arg)
    "Use `ace-window' on `prot/counsel-fzf-rg-files' candidate."
    (ace-window t)
    (let ((default-directory (if (eq (vc-root-dir) nil)
      (if (> (length (aw-window-list)) 1)
          (find-file arg)
        (find-file-other-window arg))
      (balance-windows (current-buffer))))

  ;; Pass functions as appropriate Ivy actions (accessed via M-o)
   '(("r" prot/counsel-fzf-dir "change root directory")
     ("g" prot/counsel-rg-dir "use ripgrep in root directory")
     ("a" prot/counsel-fzf-ace-window "ace-window switch")))

   '(("r" prot/counsel-rg-dir "change root directory")
     ("z" prot/counsel-fzf-dir "find file with fzf in root directory")))

   '(("g" prot/counsel-rg-dir "use ripgrep in root directory")
     ("z" prot/counsel-fzf-dir "find file with fzf in root directory")))

  ;; Remove commands that only work with key bindings
  (put 'counsel-find-symbol 'no-counsel-M-x t)
  :bind (("M-x" . counsel-M-x)
         ("C-x C-f" . counsel-find-file)
         ("s-f" . counsel-find-file)
         ("s-F" . find-file-other-window)
         ("C-x b" . ivy-switch-buffer)
         ("s-b" . ivy-switch-buffer)
         ("C-x B" . counsel-switch-buffer-other-window)
         ("s-B" . counsel-switch-buffer-other-window)
         ("C-x d" . counsel-dired)
         ("s-d" . counsel-dired)
         ("s-D" . dired-other-window)
         ("C-x C-r" . counsel-recentf)
         ("s-m" . counsel-mark-ring)
         ("s-r" . counsel-recentf)
         ("s-y" . counsel-yank-pop)
         ("C-h f" . counsel-describe-function)
         ("C-h v" . counsel-describe-variable)
         ("M-s r" . counsel-rg)
         ("M-s g" . counsel-git-grep)
         ("M-s l" . counsel-find-library)
         ("M-s z" . prot/counsel-fzf-rg-files)
         :map ivy-minibuffer-map
         ("C-r" . counsel-minibuffer-history)
         ("s-y" . ivy-next-line)        ; Avoid 2× `counsel-yank-pop'
         ("C-SPC" . ivy-restrict-to-matches))) DEPRECATED Counsel and projectile

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

I only really need a handful of commands from this setup, namely the ability to switch between buffers or directories in a project and to switch between projects. For the rest, I am already covered by what I have defined in the Counsel section above.

In case you want to use counsel-projectile to its full extent, then enable and configure :bind-keymap. That key binding is just the common prefix to a list of key chords. You can learn about them with M-s p C-h (so append C-h). Note though that the keys I define below do not require such a prefix. They call the commands I need directly.

The counsel-projectile-switch-project is configured to run the fourth action of those available, which configures it to switch to a project and open it inside of dired, rather than ask for a file to open.

While the ivy-initial-inputs-alist extends the variable that is specified in the Ivy section.

(use-package counsel-projectile
  :disabled                             ; switched to `icomplete'
  :ensure t
  (add-to-list 'ivy-initial-inputs-alist '(counsel-projectile-switch-project . ""))
  :hook (after-init . counsel-projectile-mode)
  ;; :bind-keymap ("M-s p" . projectile-command-map)
  :bind (("M-s b" . counsel-projectile-switch-to-buffer)
         ("M-s d" . counsel-projectile-find-dir)
         ("M-s p" . (lambda ()
                      (counsel-projectile-switch-project 4)))))

8.1.4 DEPRECATED Swiper commands and settings

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

This is the search tool that is powered by Ivy. I use it to get an overview of the matching candidates when performing a more complex search. It is not intended as a drop-in replacement for isearch (see section on Isearch), especially since the latter is better for recording macros and jumping to visible sections in the buffer.

Given that Swiper is related to Ivy, do not forget to review the entire section on Selection candidates and search methods.

(use-package swiper
  :disabled                             ; switched to `icomplete'
  :ensure t
  :after ivy
  (setq swiper-action-recenter t)
  (setq swiper-goto-start-of-match t)
  (setq swiper-include-line-number-in-search t)
  :bind (("C-S-s" . swiper)
         ("M-s s" . swiper-multi)
         ("M-s w" . swiper-thing-at-point)
         :map swiper-map
         ("M-%" . swiper-query-replace)))

8.1.5 DEPRECATED Ivy extensions

These tools build on the foundation of Ivy and friends. DEPRECATED Ivy rich

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

With this package we can make good use of the plenty of empty space left by Ivy's default presentation of its items. It enhances several commands, providing each of them with additional information that is pertinent to the task at hand. For example, M-x contains function descriptions, while the buffer list includes information about the major mode and file system path of the items.

The ivy-rich-path-style offers an abbreviation of the file system path that an item is referring to. So far, the only noticeable difference over an absolute value is the use of the tilde (~) instead of /home/USER/ in the buffer list. Whereas recentf continues to display absolute paths. Will need to test this further…

(use-package ivy-rich
  :disabled                             ; switched to `icomplete'
  :ensure t
  :after ivy
  (setq ivy-rich-path-style 'abbreviate)

  (setcdr (assq t ivy-format-functions-alist)
  (ivy-rich-mode 1)) DEPRECATED Ivy posframe

WARNING 2020-02-10: I have switched to a simpler, custom solution that uses the built-in icomplete tool. All deprecated packages contain the special :disabled keyword. For the new system, refer to the previous sections:

Below is the latest state of these settings prior to the switch.

This package allows us to reposition Ivy's window anywhere inside of the Emacs frame by placing it inside of a so-called "child frame", i.e. the "posframe". Furthermore, it is possible to use this feature on a per-command basis, all while assigning a different height to each function.

The ivy-posframe-parameters can be found in the source code of the main library. Do M-x find-library RET posframe RET where RET means to hit the Return key in order to proceed. In one of the parameters I show how to define a font that is different from what would normally be used (see this document's section on fonts).

(use-package ivy-posframe
  :disabled                             ; switched to `icomplete'
  :ensure t
  :after ivy
  (setq ivy-posframe-parameters
        '((left-fringe . 2)
          (right-fringe . 2)
          (internal-border-width . 2)
          ;; (font . "DejaVu Sans Mono-10.75:hintstyle=hintfull")
  (setq ivy-posframe-height-alist
        '((swiper . 15)
          (swiper-isearch . 15)
          (t . 10)))
  (setq ivy-posframe-display-functions-alist
        '((complete-symbol . ivy-posframe-display-at-point)
          (swiper . nil)
          (swiper-isearch . nil)
          (t . ivy-posframe-display-at-frame-center)))
  (ivy-posframe-mode 1))

8.2 DEPRECATED Reading email with MU4E

WARNING (2020-01-30): I am no longer using MU4E as I switched to Gnus. This section is only kept for reference.

The following configure mu4e, the Mail User Agent. An overview:

  • Include mu4e in the load path. This is necessary because we are using the GNU/Linux distro's package.
  • Use mu4e as the default MUA in Emacs. This concerns actions such as C-x m (compose-mail).
  • I prefer to run the "get mail" command manually rather than rely on a timer. The idea is that when I have time to check my email, I can also refresh its index.
  • Do not provide verbose output about indexing operations.
  • Update manually, because I anyway interact with email only when I have time to check it.
  • Use my selected completion framework where relevant.
  • Define my signature and include it in new messages.
  • Specify the directory where mail is stored. This is where offlineimap is configured to place its findings. Each email account has its own subdirectory therein.
  • Careful with this: Store sent messages in their appropriate place (defined in the "contexts" file—see further below). The docs suggest that IMAP accounts should opt for either moving messages to the trash directory or outright deleting them. The idea is that IMAP is supposed to handle this stuff automatically—my initial tests with my configs do not confirm this, which is why I just tell it to place them in the "sent" directory.
  • Do not kill message buffer upon exit from it. It can always be useful to quickly check something.
  • Always show email addresses (the default is to display just the name).
  • The variables that concern mu4e contexts are relevant because of prot/mu4e-contexts. It loads the mu4e-contexts with all the information about my account setup. I set this in a private and encrypted file. Do check the example in the official docs. I based my work off of it.
  • Message citation is just an improved format for quoting a message in a reply. The format looks like "On 2019-12-09, 16:50 (CET), PERSON <EMAIL> wrote:".
(use-package mu4e
  :disabled                             ; DEPRECATED in favour of `gnus'
  :load-path "/usr/share/emacs/site-lisp/mu4e"
  :after (smtpmail smtpmail-async)
  :commands (mu4e mu4e-update-mail-and-index)
  (setq mail-user-agent 'mu4e-user-agent)
  (setq mu4e-get-mail-command "offlineimap")
  (setq mu4e-hide-index-messages t)
  (setq mu4e-update-interval nil)
  (setq mu4e-completing-read-function 'completing-read)
  (setq mu4e-compose-signature "Protesilaos Stavrou\nprotesilaos.com\n")
  (setq mu4e-compose-signature-auto-include t)
  (setq mu4e-maildir "~/Maildir")
  (setq mu4e-sent-messages-behavior 'sent)
  (setq message-kill-buffer-on-exit nil)
  (setq mu4e-view-show-addresses t)
  (setq mu4e-context-policy 'pick-first)
  (setq mu4e-compose-context-policy 'ask)
  (setq message-citation-line-format "On %Y-%m-%d, %R (%Z), %f wrote:\n")
  (setq message-citation-line-function 'message-insert-formatted-citation-line)

  (defun prot/mu4e-contexts ()
    "Loads a file with the specifics of my email account info."
    (let ((mails "~/.emacs.d/mu4e-contexts.el.gpg"))
      (when (file-exists-p mails)
        (load-file mails))))
  :hook (after-init . prot/mu4e-contexts)
  :bind (:map mu4e-main-mode-map
              ("g" . mu4e-update-mail-and-index)))

To set up offlineimap I used the Arch Wiki entry.

8.2.1 DEPRECATED mu4e extension for org-capture

WARNING (2020-01-30): I am no longer using MU4E as I switched to Gnus. This section is only kept for reference.

With this little snippet, we allow org-capture convert any email into a note, to-do item or whatever. The killer feature is that we get a direct link back to the original email. This way, we can avoid the problem of searching through a pile of messages until we find the one we really need. Nice!

(use-package org-mu4e                   ; no need for `:ensure t'
  :disabled                             ; DEPRECATED in favour of `gnus'
  :after (org mu4e)
  (setq org-mu4e-link-query-in-headers-mode nil))