By default, Emacs uses dynamic binding. In order to use closures, I enable lexical binding.

;; -*- lexical-binding: t -*-

I prefer a dark color theme. It’s much easier on the eyes, and I like working in the night often in dark rooms without any other lighting.

(load-theme 'manoj-dark)

Set the font size to something reasonable. The font size is in units of 1/10 pt. So, by setting :height to 120, I have set the font size to 12 pt. The default font face is what all other font faces base on.

I use the tamil99 input method to type Tamil text. But, I also use a dvorak keyboard sometimes, and this really messes up the key mapping of the tamil99 input method. So, I need to tell quail about my keyboard layout so it can correct its mapping.

(setq default-input-method "tamil99")

(with-eval-after-load 'quail
  (defun interleave-caps (str)
    "Interleave characters in STR with their capital forms."
    (mapconcat (lambda (c)
                 (string c (upcase c)))
               str ""))

  (setq quail-keyboard-layout-alist
        (map-insert quail-keyboard-layout-alist
                    "programmer-dvorak"
                    (let ((rows 6)
                          (columns 15))
                      (concat
                       ;; No row 1
                       (make-string (* 2 columns) ?\s)
                       ;; Row 2
                       "  1!2@3#4$5%6^7&8*9(0)" (make-string (* 2 4) ?\s)
                       ;; Row 3
                       "  ;:,<.>" (interleave-caps "pyfgcrl") "/?\\|" (make-string (* 2 2) ?\s)
                       ;; Row 4
                       "  " (interleave-caps "aoeuidhtns") "-_" (make-string (* 2 3) ?\s)
                       ;; Row 5
                       "  '\"" (interleave-caps "qjkxbmwvz    ")
                       ;; No row 6
                       (make-string (* 2 columns) ?\s)))))

  ;; Uncomment whichever I need.
  (quail-set-keyboard-layout "programmer-dvorak")
  ;; (quail-set-keyboard-layout "standard")
  )

First things first, set up the package manager. Define the list of repos and initialize installed packages. More and more, I only use Emacs packages from my distro, GNU GuixSD. But, from time to time, I still need MELPA.

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

Autoloading lets you speed up Emacs startup and reduce memory usage by postponing loading files until the last moment when some command requiring that file is invoked.

Wherever necessary, I have wrapped up forms in the built-in with-eval-after-load macro so that they run only after some file is loaded.

Emacs starts with, several commands that would be confusing to the uninitiated, disabled. We enable some of them.

(put 'erase-buffer 'disabled nil)
(put 'narrow-to-region 'disabled nil)
(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)

Indent using spaces instead of tabs. Since indent-tabs-mode is a buffer-local variable, set its default value. If we set its value using setq, it only applies to the current buffer.

(setq-default indent-tabs-mode nil)

Emacs defaults to an antiquated typewriter practice whereby sentences where separated by two spaces. Disable this to use the more intuitive modern practice of a single space

(setq sentence-end-double-space nil)

Emacs’ kill ring is distinct from the system clipboard. Emacs does a decent job of integrating the two and pretending they’re the same. But there’s one annoying quirk—when you copy something from an external program (say, a web browser) and you kill without yanking, the text from the external program is forever lost. This is an itty-bitty detail, but the consequences are real and annoying. We fix this here. Sometimes, Emacs really lacks sensible defaults!

(setq save-interprogram-paste-before-kill t)

Use the sensible day/month/year date style that the majority of the world uses.

(setq calendar-date-style 'european)

One should never be able to accidentally kill the scratch buffer; prevent it. Prevention is better than cure.

(with-current-buffer "*scratch*"
  (emacs-lock-mode 'kill))

I don’t want backup files littering my folders. I use version control systems a lot anyway.

(setq make-backup-files nil)

Coming from a Vim background, I prefer to not have menu bars and tool bars clutter my limited screen real estate. I like all of the screen devoted to just text. Menu bars are very useful to discover new features, but I can always enable them when I need to, instead of keeping them permanently enabled.

(menu-bar-mode 0)
(tool-bar-mode 0)

A lot of my work in emacs involves writing using org mode and latex. Word wrapping and the use of “visual lines” is absolutely important for this.

(global-visual-line-mode t)

Highlighting matching parentheses is really important when coding. I don’t know why this is not enabled by default in emacs.

(show-paren-mode)

Emacs’ default modeline is positively ugly. Here’s a decent one—smart-mode-line.

(setq sml/theme 'dark
      sml/no-confirm-load-theme t)
(sml/setup)

In the absence of a full fledged desktop environment, it is still nice to see the current battery and average system load (but not the time—see Clock-free life). Let’s activate display-battery-mode and display-time.

(display-battery-mode)
(display-time)

In order to get keybindings to work across all buffers (both external program buffers managed by exwm and other Emacs buffers), I bind them using exwm-input-set-key.

I might have to bind key sequences to not just Emacs commands, but also to external programs. For this, the external program needs to be wrapped up in an Emacs command. This wrapping is handled by make-external-command. make-external-command returns a command that invokes the external program if it isn’t already running, switches to the buffer of the external program if it is already running, and switches to the last used buffer¹ if the external program is already running and is the current buffer. This makes it easy to start an external program, switch to it, and switch back from it all using the same keybinding. Similarly, we have start-shell to switch back and forth between a shell and some other buffer.

(require 'exwm)

(defun switch-to-last-used-buffer ()
  (interactive)
  (switch-to-buffer (other-buffer (current-buffer) t)))

(defun make-external-command (command)
  (lambda ()
    (interactive)
    (let ((buffer-name (car (split-string command))))
      (cond
       ((equal buffer-name (buffer-name))
        (switch-to-last-used-buffer))
       ((get-buffer buffer-name)
        (switch-to-buffer (get-buffer buffer-name)))
       (t (start-process-shell-command buffer-name nil command))))))

(defun start-shell ()
  (interactive)
  (if (equal (buffer-name) "*shell*")
      (switch-to-last-used-buffer)
    (shell)))

I then bind a lot of external programs to the function and media keys.

(exwm-input-set-key (kbd "<XF86MonBrightnessDown>")
                    (make-external-command "light -U 5"))
(exwm-input-set-key (kbd "<XF86MonBrightnessUp>")
                    (make-external-command "light -A 5"))
(exwm-input-set-key (kbd "<XF86AudioMute>")
                    (make-external-command "amixer set Master toggle"))
(exwm-input-set-key (kbd "<XF86AudioLowerVolume>")
                    (make-external-command "amixer set Master 5%-"))
(exwm-input-set-key (kbd "<XF86AudioRaiseVolume>")
                    (make-external-command "amixer set Master 5%+"))
(exwm-input-set-key (kbd "<XF86HomePage>")
                    (make-external-command "icecat"))
(exwm-input-set-key (kbd "<XF86Sleep>")
                    (make-external-command "loginctl suspend"))
(exwm-input-set-key (kbd "<S-XF86Sleep>")
                    (make-external-command "loginctl suspend; slock"))
(exwm-input-set-key (kbd "s-1") 'delete-other-windows)
(exwm-input-set-key (kbd "s-2") (make-external-command "nyxt"))
(exwm-input-set-key (kbd "s-3") 'start-shell)
(exwm-input-set-key (kbd "<menu>") 'execute-extended-command)
(exwm-input-set-key (kbd "s-f") 'find-file)
(exwm-input-set-key (kbd "s-k") 'kill-buffer)

I might still need to run external programs not covered above with the function and media keys. For these, I have a command run-external-program that prompts for the program to run and starts it using start-process-shell-command. The prompt provides all executables in PATH as completions. When building a list of completions, care is taken to filter out non-existent directories in PATH.

(let ((executables (seq-mapcat (lambda (bin)
                                 (when (file-exists-p bin)
                                   (directory-files bin nil (rx string-start (not ?.)))))
                               exec-path)))
  (defun run-external-program (command)
    (interactive (list (completing-read "$ " executables)))
    (start-process-shell-command command nil command)))

(exwm-input-set-key (kbd "s-r") 'run-external-program)

I want exwm buffers to be named according to the programs they are running.

(add-hook 'exwm-update-class-hook
          (lambda ()
            (exwm-workspace-rename-buffer
             (downcase exwm-class-name))))

Finally, I enable exwm.

(exwm-enable)

exwm-edit is a really handy EXWM extension that lets you edit any text area in any program using Emacs. This means I get to use Emacs even when filling out boring web forms and I get to use the Emacs tamil99 input method everywhere without having to install something like ibus.

(require 'exwm-edit)
(global-exwm-edit-mode)

In programming modes, it’s useful to know how close to the edge you are. The display-fill-column-indicator-mode adds a line showing you the edge.

(add-hook 'prog-mode-hook 'display-fill-column-indicator-mode)

For the lisps, after trying many structured editing packages, I have returned to the humble paredit and Emacs’ own S-expression editing commands.

(mapc (lambda (hook)
        (add-hook hook 'paredit-mode))
      (list 'emacs-lisp-mode-hook 'lisp-interaction-mode-hook
            'lisp-mode-hook 'lisp-data-mode-hook 'scheme-mode-hook))

In addition, we need the skribilo minor mode for skribilo files.

(setf (map-elt auto-mode-alist (rx ".skb" string-end) nil 'equal)
      'skribilo-mode)

I keep accounts with ledger. Here, I tell Emacs to automatically open .ledger files in ledger-mode.

(add-to-list 'auto-mode-alist '("\\.ledger" . ledger-mode))

Gnuplot mode provides syntax highlighting, indentation and a few other convenient functions for editing gnuplot scripts. Unfortunately, by default, gnuplot mode only recognizes file extensions .gp and .gnuplot as gnuplot scripts, while Vim recognizes the .gpi extension. I don’t want to have to rename all my gnuplot scripts. So, I just tell gnuplot mode to recognize the .gpi extension as well.

(add-to-list 'auto-mode-alist '("\\.gpi" . gnuplot-mode))

Octave mode is a major mode for editing Octave programs. I set Octave mode to recognize .m files as Octave source files. Without this, .m files are opened in Objective C mode, which I have no need for.

(map-put auto-mode-alist "\\.m$" 'octave-mode)

In my markdown modes, I prefer soft line breaks with automatic word wrapping. I used to love fill-paragraph and M-q was deeply ingrained in my muscle memory. But, I’ve outgrown it now, and instead use visual-fill-column-mode to automatically soft-wrap text.

(with-eval-after-load 'org
  (add-hook 'org-mode-hook 'visual-fill-column-mode))

(with-eval-after-load 'gemini-mode
  (add-hook 'gemini-mode-hook 'visual-fill-column-mode))

(with-eval-after-load 'markdown-mode
  (add-hook 'markdown-mode-hook 'visual-fill-column-mode))

Org Tempo provides “structure templates” for SRC blocks among other things. Very handy since I find myself creating SRC blocks all the time.

(require 'org-tempo)

Set notmuch as the mail user agent.

(setq mail-user-agent 'notmuch-user-agent)

Email encryption can sure do with some assistance from automation. Without automation, it is easy to forget to encrypt.

When encrypting outgoing emails, I also encrypt to myself so that I can read my own archives later. If I didn’t, I would be left with opaque encrypted blobs in my archives.

(setq mml-secure-openpgp-encrypt-to-self t)

Configure Emacs to automatically encrypt when both the following are true:

• I have a private key for the email address I am sending from
• I have the public keys of all my correspondents

(defun encrypt-when-possible ()
  (when (and (secret-key-available-p
              (canonical-email-address (message-fetch-field "From")))
             (message-all-epg-keys-available-p))
    (mml-secure-message-sign-encrypt)))

(add-hook 'message-send-hook 'encrypt-when-possible)

And, here’s the implementation of secret-key-available-p.

(defun canonical-email-address (address)
  "Return the canonical address part of email ADDRESS.

For example, (canonical-email-address \"Foo <foo@example.com>\")
=> \"foo@example.com\""
  (pcase (mail-extract-address-components address)
    (`(,_ ,canonical-address) canonical-address)))

(defun secret-key-available-p (email-address)
  "Check if secret key is available for EMAIL-ADDRESS.

Return non-nil if a valid secret key is available for
EMAIL-ADDRESS. EMAIL-ADDRESS is a canonical email address without
the name."
  (seq-some (lambda (key)
              (seq-some (lambda (user-id)
                          (and (string= (canonical-email-address
                                         (epg-user-id-string user-id))
                                        email-address)
                               (not (eq (epg-user-id-validity user-id)
                                        'revoked))))
                        (epg-key-user-id-list key)))
            (epg-list-keys (epg-make-context epa-protocol)
                           email-address t)))

Earlier, I used to automatically sign all outgoing emails regardless of whether my correspondents knew about PGP. This ended up confusing and maybe even annoying some people since they would mistake the signatures for attachments. So, I have stopped doing this. Nevertheless, here is the function if anyone needs it.

(defun sign-or-encrypt-when-possible ()
  (when (secret-key-available-p
         (canonical-email-address (message-fetch-field "From")))
    (if (message-all-epg-keys-available-p)
        (mml-secure-message-sign-encrypt)
      (mml-secure-message-sign))))

With its convenient emacsy interface and good Emacs integration, Dired is the text based file manager that finally convinced me to quit the GUI file managers I was using earlier. I spend so much time in Emacs (programming, mail, browsing, blogging, getting things done with org mode, etc.) that an Emacs based file manager is just the natural thing to have!

In Dired’s file listings, I prefer seeing approximate human readable file sizes (such as 1K, 234M, 2G, etc.) instead of the number of bytes which are usually too large to be meaningfully interpreted by a human being. Hence I’ve added the -h switch to Dired’s ls calls.

(with-eval-after-load 'dired
  (setq dired-listing-switches "-alh"))

Likewise, I want to be able to open files using the right program automagically like GUI file managers do. Hence, I set up openwith-mode with my preferred file-program associations.

(openwith-mode)

(setq openwith-associations
      `((,(rx (or ".djvu" ".eps" ".pdf" ".ps") string-end)
         "zathura" (file))
        (,(rx (or ".aac" ".avi" ".m4a" ".mkv" ".mp3" ".mp4" ".ogv" ".webm")
              (optional ".part")
              string-end)
         "mpv" (file))
        (,(rx (or ".doc" ".docx"
                  ".odt" ".ods"
                  ".ppt" ".pptx"
                  ".xls" ".xlsx")
              string-end)
         "libreoffice" (file))))

I live a clock-free life outside the tyranny of the clock as much as I can reasonably help it. I don’t want to know the precise hour and minute of every moment of the day. It is much less stressful to live by imprecise natural time afforded by the movement of the Sun. I therefore don’t want to have a clock on my modeline, although I’d still like to see the average system load. So, set the time format of display-time-mode to the empty string.

(setq display-time-format "")

Collaborating across timezones is complicated and subject to the mysteries of daylight savings. I use world-time-mode, for which I need to configure all the timezones I am interested in in display-time-world-list.

(setq display-time-world-list
      `(("Europe/London" "இலண்டன்")
        ("Asia/Kolkata" "பெங்களூர்")
        ("Africa/Nairobi" "நைரோபி")
        ("America/Chicago" "மெம்பிசு")
        ("America/New_York" "புதிய யோர்க்")
        ("America/Los_Angeles" "இலாஸ் ஏஞ்சலெஸ்")
        ("Europe/Amsterdam" "ஆம்சுடர்டாம்")
        ("Europe/Paris" "பாரிசு")
        ("Europe/Athens" "ஆதென்சு")
        ("Asia/Jerusalem" "இயெருசலேம்")))