My Literate .emacs.d

I go to the pretest FTP to get the latest version of Emacs. Usually not quite up-to-date with the master branch, but still one version number ahead of the most recent official release.

On macOS, I've had the best luck with jimeh's nightly builds. These Emacs.app bundles have no external dependencies, signed with a developer certificate, and notarized by Apple, so it just works. Even without administrator permissions, you can drag the bundle to the "Applications" folder under your user home instead, and Emacs still works beautifully.

In particular, this feature has saved me a lot of headaches that I ran into compiling Emacs on my own:

Emacs.app is signed with a developer certificate and notarized by Apple.

Very nice!

Depending on the machine, I get Emacs one of several ways in a GNU/Linux setup. These rank from highest to lowest priority:

1. Through my system package manager, such as sudo apt-get install emacs or pacman -S emacs
2. Through the official FTP
3. Through the pretest FTP
4. Through condax
5. Compiling it myself

Windows, funnily enough, has some trouble registering the Windows key as a usable modifier for Emacs. In fact, s-l will never be an option, since it's handled at the hardware level.

(defun renz/windowsp ()
  "Are we on Microsoft Windows?"
  (memq system-type '(windows-nt cygwin ms-dos)))

(when (and (renz/windowsp) (executable-find "pwsh"))
  (setq shell-file-name "pwsh"))

There are a few things I set up independent of Emacs. Namely, find, xargs, and rg. These days, I can usually install these things with winget:

winget install BurntSushi.ripgrep.GNU
winget install GnuWin32.FindUtils
winget install GnuWin32.Grep
winget install RubyInstallerTeam.RubyWithDevKit.3.2  # For building my website with Jekyll
winget install Python.Python.3.11  # I work a lot in python

You can use Emacs without these, but some commands like M-x grep or M-x project-find-regexp will not work without making sure the GNU version of find and grep (or a suitable replacement) are on your PATH. I tend not to muck with PATH inside Emacs if I can help it, and instead launch Emacs from powershell where things are properly set. Usually I'll have some things like this in my $PROFILE:

$ENV:Path = "${ENV:ProgramFiles}\Hunspell\bin\;" + $ENV:Path
$ENV:Path = "${ENV:ProgramFiles(x86)}\GnuWin32\bin\;" + $ENV:Path
$ENV:Path = "${ENV:ProgramFiles}\Emacs\emacs-29.1\bin\;" + $ENV:Path
$ENV:PROFILE = $PROFILE
$ENV:LANG = "en_US"
$ENV:DICPATH = "$ENV:ProgramFiles\Hunspell\"

The duplicate $PROFILE thing is so we can access that file through C-x C-f $PROFILE within Emacs. Check out the Spellchecking section on the Hunspell stuff.

Launching Emacs from the typical application launcher or command-space usually won't capture any modifications to $PATH, typically handled in a file like ~/.profile or ~/.bashrc. So, the main configuration included here is from exec-path-from-shell.

(when (eq system-type 'darwin)
  (setq exec-path-from-shell-arguments '("-l"))
  (exec-path-from-shell-initialize))

This snippet has a special place in my heart, because it was the first two lines of elisp I wrote when first learning Emacs. It is the central kernel around which my ~/.emacs and later ~/.emacs.d/init.el grew.

;; Stop stupid bell
(setq ring-bell-function 'ignore)

The bell is really, really annoying.

Sometimes (especially on Windows), Emacs gets confused about what encoding to use. These settings try to prevent that confusion.

(prefer-coding-system       'utf-8)
(set-default-coding-systems 'utf-8)
(set-terminal-coding-system 'utf-8)
(set-keyboard-coding-system 'utf-8)
(setq default-buffer-file-coding-system 'utf-8)
(setq x-select-request-type '(UTF8_STRING COMPOUND_TEXT TEXT STRING))

It's easy for the mode line to get cluttered once things like Flymake and eglot kick in. When I was starting out, I used to have these two settings:

(setq display-battery-mode t
      display-time-day-and-date t)
(display-time)

After a while I noticed that I'm almost never running Emacs in a full screen where I can't see the battery or date in the corner of my window manager, so they were just wasting mode line space. Nowadays I simply opt for column mode and a dimmed mode line in non-selected windows.

(setq column-number-mode t
      mode-line-in-non-selected-windows t)

Found this on a System Crafters video.

(setq history-length 25)
(savehist-mode 1)

For files containing color escape codes, this provides a way to render the colors in-buffer. Provided by a helpful stackoverflow answer.

(defun renz/display-ansi-colors ()
  "Render colors in a buffer that contains ASCII color escape codes."
  (interactive)
  (require 'ansi-color)
  (let ((inhibit-read-only t))
    (ansi-color-apply-on-region (point-min) (point-max))))

This enables "File -> Open Recent" from the menu bar and using completing-read over the recentf-list.

(recentf-mode t)
(defun renz/find-recent-file ()
“Find a file that was recently visted using `completing-read’.”
(interactive)
(find-file (completing-read “Find recent file: " recentf-list nil t)))

Regardless of whether we're doing visual fill or hard fill, I like the default at around 80 characters, and I'll manually change it per buffer if I want something different

(setq-default fill-column 80)

I toggle this one on/off sometimes depending on how I feel and which OS I'm currently on.

(scroll-bar-mode -1)

By default, though, I prefer it to be off when I start Emacs.

This hunk adds some space around all sides of each window so that we get a clear space between the edge of the screen and the fringe.

(defun renz/modify-margins ()
  "Add some space around each window."
  (interactive)
  (modify-all-frames-parameters
   '((right-divider-width . 40)
     (internal-border-width . 40)))
  (dolist (face '(window-divider
                  window-divider-first-pixel
                  window-divider-last-pixel))
    (face-spec-reset-face face)
    (set-face-foreground face (face-attribute 'default :background)))
  (set-face-background 'fringe (face-attribute 'default :background)))
(renz/modify-margins)

We also need to make sure this runs each time we change the ef-theme, otherwise the old background color will linger in the margins.

(add-hook 'ef-themes-post-load-hook 'renz/modify-margins)

When navigating to a file that is a symlink, this automatically redirects us to the source file it's pointing to.

(setq find-file-visit-truename t)
(setq vc-follow-symlinks t)

For the most part I edit Python, SQL, Markdown, Org, and shell scripts. All of these favor spaces over tabs, so I prefer this as the default.

(setq-default indent-tabs-mode nil)

Generally, though, indentation behavior is set by major-mode functions, which may or may not use Emacs' built-in indentation functions. For instance, when trying to find the functions behind indentation in shell mode, I came across smie.el, whose introductory comments include this gem:

OTOH we had to kill many chickens, read many coffee grounds, and practice untold numbers of black magic spells, to come up with the indentation code. Since then, some of that code has been beaten into submission, but the `smie-indent-keyword' function is still pretty obscure.

Even the GNU manual speaks of it in the same way:

Writing a good indentation function can be difficult and to a large extent it is still a black art. Many major mode authors will start by writing a simple indentation function that works for simple cases, for example by comparing with the indentation of the previous text line. For most programming languages that are not really line-based, this tends to scale very poorly: improving such a function to let it handle more diverse situations tends to become more and more difficult, resulting in the end with a large, complex, unmaintainable indentation function which nobody dares to touch.

From a helpful stackoverflow answer.

(setq mouse-wheel-tilt-scroll t)

From a Mickey Petersen article, this causes switch-to-buffer to open the selected buffer in the current window rather than switching windows, assuming both are open in the current frame. This is more frequently the behavior I intend when I'm trying to get a window to display a specific buffer.

(unless (version< emacs-version "27.1")
  (setq switch-to-buffer-obey-display-actions t))

Without setting global-auto-revert-mode, we have to remember to issue a revert-buffer or revert-buffer-quick (C-x x g by default) in case a file changed. Over Tramp, we still have to manually revert files when they've changed on disk.

(global-auto-revert-mode)

Add a faint background highlight to the line we're editing.

(add-hook 'prog-mode-hook #'hl-line-mode)
(add-hook 'text-mode-hook #'hl-line-mode)
(add-hook 'org-mode-hook #'hl-line-mode)

(add-hook 'prog-mode-hook #'flymake-mode)

Another, related mode is flyspell-prog-mode, which is just checks spelling in comments and strings.

(add-hook 'prog-mode-hook #'flyspell-prog-mode)

I would also like to have a good-looking display for trailing whitespace and leading tabs like in my Neovim setup, but it has proven challenging to just narrow down to those two faces. In the interim, I toggle M-x whitespace-mode to check for mixed tabs, spaces, and line endings.

(add-hook 'before-save-hook 'delete-trailing-whitespace)

Typically, Emacs will ask you to confirm before killing a buffer that has a running process, such as with run-python, a *shell* buffer, or a *compilation* buffer.

(setq kill-buffer-query-functions
  (remq 'process-kill-buffer-query-function
         kill-buffer-query-functions))

I much prefer having long lines simply spill off to the right of the screen than having them wrap around onto the next line, except in the case where I'd like to see wrapped line content, like in one of the shell modes.

(setq-default truncate-lines t)
(add-hook 'eshell-mode-hook (lambda () (setq-local truncate-lines nil)))
(add-hook 'shell-mode-hook (lambda () (setq-local truncate-lines nil)))

For programming and prose/writing modes.

Unfortunately, line numbers are displayed in the text area of the buffer, but org-modern uses the fringe to display source blocks. There's no way to display them to the left of the fringe, so I'm careful about only turning on line numbers in modes that I think I'll benefit from it. It's been working pretty well in org-mode without the line numbers so far, since for each of the code blocks I can always use C-c ' to edit in prog-mode, where I do get line numbers.

(defun renz/display-relative-lines ()
  (setq display-line-numbers 'relative))
(add-hook ‘prog-mode-hook #‘renz/display-relative-lines)
(add-hook ‘yaml-mode-hook #‘renz/display-relative-lines)
(unless (display-graphic-p)
(add-hook ’text-mode-hook #‘renz/display-relative-lines))

I just think that's a funny sentence. Normally when yanking text with an active region, the region will remain and the yanked text is just inserted at point. I prefer the modern word processor behavior of replacing the selected text with the yanked content.

(delete-selection-mode t)

As new text appears, the default behavior is for it to spill off the bottom, unless we manually scroll to the end of the buffer. Instead, I prefer the window to automatically scroll along with text as it appears, stopping at the first error that appears.

(setq compilation-scroll-output 'first-error)

I usually leave the tool bar disabled

(tool-bar-mode -1)

The menu bar, on the other hand (menu-bar-mode), is very handy, and I only disable it on Windows, where it looks hideous if I'm running in dark mode.

(when (renz/windowsp)
  (menu-bar-mode -1))

For newcomers to Emacs, I would strongly discourage disabling the menu bar, as it is the most straightforward way to discover Emacs' most useful features.

From an Emacs stackexchange answer.

(advice-add 'risky-local-variable-p :override #'ignore)

(use-package grep
  :config
  (when (executable-find "rg")
    (setq grep-program "rg")
    (grep-apply-setting
     'grep-find-command
     '("rg -n -H --color always --no-heading -e '' $(git rev-parse --show-toplevel || pwd)" . 27))))

If you're on Windows, this command assumes you're running pwsh version 7 or higher.

It's very annoying when I'm working and suddenly I meant to do C-c C-x, but instead hit C-x C-c. This helps prevent that.

(setq confirm-kill-emacs 'yes-or-no-p)

Emacs 29 introduced smooth, pixel-level scrolling, which removes much of the "jumpiness" you see when scrolling past images.

(if (version< emacs-version "29.0")
    (pixel-scroll-mode)
  (pixel-scroll-precision-mode 1)
  (setq pixel-scroll-precision-large-scroll-height 35.0))

On macOS and linux I typically use aspell, given how easy it is to install. For Windows, I'll set up hunspell, which I install from the hunspell-binary repo. After installing the hunspell binary, it requires installing a dictionary and affix file to the installation directory:

curl -o en_US.dic https://cgit.freedesktop.org/libreoffice/dictionaries/plain/en/en_US.dic?id=a4473e06b56bfe35187e302754f6baaa8d75e54f
curl -o en_US.aff https://cgit.freedesktop.org/libreoffice/dictionaries/plain/en/en_US.aff?id=a4473e06b56bfe35187e302754f6baaa8d75e54f

Then move these files to wherever hunspell is. For instance, C:\Program Files\Hunspell.

(cond ((executable-find "aspell")
       (setq ispell-program-name "aspell"
             ispell-really-aspell t))
      ((executable-find "hunspell")
       (setq ispell-program-name "hunspell"
             ispell-really-hunspell t)))

Keep all backup files in a temporary folder. At the moment I have some "file not found" errors popping up during auto-save on Windows. Once I debug that, I'll uncomment the second part.

(setq backup-directory-alist '(("." . "~/.emacs.d/backups/"))
      ;; auto-save-file-name-transforms '(("." ,temporary-file-directory t))
      )

narrow-to-region restricts editing in this buffer to the current region. The rest of the text becomes temporarily invisible and untouchable but is not deleted; if you save the buffer in a file, the invisible text is included in the file. C-x n w makes all visible again.

(put 'narrow-to-region 'disabled nil)

Allows us to convert entire regions to upper or lower case.

(put 'upcase-region 'disabled nil)
(put 'downcase-region 'disabled nil)

16 is the default number of marks stored on the global and local mark rings is 16. I hop around much more than 16 times as I'm editing, so I expand this a bit.

(setq-default mark-ring-max 32)
(setq global-mark-ring-max 32)

Another handy shortcut is continually popping marks by repeated C-<SPC> after the first C-u C-<SPC> through the set-mark-command-repeat-pop setting.

(setq set-mark-command-repeat-pop t)

And, because I always forget it, to pop a global mark you use C-x C-<SPC>. The local version, C-u C-<SPC> will only pop marks from the current buffer. So the C-x C-<SPC> version is much closer to how Vim's jump stack works.

A handy "bookmark" system (aside from actual bookmarks) is to set common buffers and files to registers pre-emptively.

(set-register ?S '(buffer . "*scratch*"))
(set-register ?I `(file . ,(expand-file-name "README.org" user-emacs-directory)))
(set-register ?B `(file . "~/.bashrc"))

The default keybinding for jump-to-register is C-x r j R, where R is the name of the register. My own personal convention here is to use lower-case letter for interactive session bookmarks that will be lost between sessions, and upper-case letters for ones I've set permanently here.

Before I was aware of this feature I had created my own jump-to-X style functions, but this is much better! You even get a handy pop-up if you wait a second after typing C-x r j to see all the available registers.

These convenient chords allow for fast text replacement by holding C-M- and rapidly typing k and h in succession.

(global-set-key (kbd "C-M-<backspace>") 'backward-kill-sexp)
(global-set-key (kbd "C-M-h") 'backward-kill-sexp)

The next line UNBINDS the suspend-frame keybinding. Accidentally minimizing on the GUI was frustrating as hell, so now I use C-x C-z if I really want to suspend the frame.

(global-set-key (kbd "C-z") #'zap-up-to-char)

Hippie-expand is purported to be a better version of dabbrev, but I rather like the default behavior of dabbrev.

(global-set-key [remap dabbrev-expand] 'hippie-expand)

ibuffer is a strictly superior, built-in version of its counterpart.

(global-set-key [remap list-buffers] 'ibuffer)

The most common situation where I'm running flymake would be for spelling in prose, or diagnostics from a language server. In either case, I like having next/previous on easy to reach chords.

(use-package flymake
  :bind (:map flymake-mode-map
         ("C-c n" . flymake-goto-next-error)
         ("C-c p" . flymake-goto-prev-error)))

Some default bindings aren't useful for me, so I bind them to actions I take more frequently.

(global-set-key (kbd "C-x C-p") 'previous-buffer)  ; Overrides `mark-page'
(global-set-key (kbd "C-x C-n") 'next-buffer)      ; Overrides `set-goal-column'

Emacs has some standards about where user-configured keys should go; C-c <letter> is always free for users. It may seem like overkill how I set a header for each possible C-c combination, but it's incredibly handy when I want to jump directly to one of these headings while in another buffer. See e.g. org-goto, which allows me to narrow in on a particular key I'd like to bind by leveraging completing-read. If a C-c <letter> combination is missing as a header, then I'm probably using it in a :bind statement with use-package somewhere else.

Like the C-c <letter> bindings, these are reserved for users. In practice, even though there are few of these keys, I tend to forget which is which. So I wind up using things bound to my C-c keymaps instead. The C-c kyes from a more natural, nested language in my head, so it feels more like I'm "speaking Emacs" that way.

For both the minibuffer and completion-at-point, I use the same completion style. Completion style is the method of assigning completion candidates to a given input string. flex is the built-in "fuzzy" completion style, familiar to us from symbol completion in IDEs and VSCode's command palette. basic functions much like your default TAB-complete at a Bash shell.

(setq completion-styles '(flex basic partial-completion emacs22))

With the completion style set, we now have to configure the interface for displaying candidates as we type. First, I want candidates displayed as a single, vertical list.

(setq completions-format 'one-column)

Also, when using the built-in completion-at-point, the *Completions* buffer can sometimes take up the whole screen when there are a lot of candidates.

(unless (version< emacs-version "29.0")
  (setq completions-max-height 15))

Some time ago, Prot wrote a package called MCT (Minibuffer and Completions in Tandem) that enhanced the default minibuffer and *Completions* buffer behavior to act more like what we expect of a modern editor's auto-complete. He discontinued development of that project once it became clear that Emacs 29 was going to include similar behavior as a configurable option. These are the options in question.

(unless (version< emacs-version "29.0")
  (setq completion-auto-help 'lazy
        completion-auto-select 'second-tab
        completion-show-help nil
        completions-sort nil
        completions-header-format nil))

By default, Emacs uses M-TAB, or the equivalent C-M-i for completion-at-point. I'd much prefer to use the easier and more intuitive TAB.

(setq tab-always-indent 'complete)

Something I might try is to use icomplete along with icomplete-in-buffer to get something like a little window that updates as I type. It seems a little wonky, since TAB-completion will still cause the ∗Completions∗ buffer to pop up, even while Icomplete is active, unless we set completion-auto-help to lazy; and even then it will still come up on the second TAB press.

(setq icomplete-in-buffer t)
(setq icomplete-prospects-height 10)
(icomplete-vertical-mode t)

In the case that we need to enter a new file name, but fido is still showing a completion candidate, you have to use C-d to refuse completion and take whatever is currently in the prompt. For instance, if we are editing a file hello.py, and then use C-x C-f hell.py, the minibuffer will complete hell.py into hello.py if we use RET, and will open a new buffer for hell.py if we use C-d.

This changes the behavior of a few commonly-used tags in web pages that I write.

(use-package sgml-mode
  :defer t
  :config
  (let* ((p-tag-old (assoc "p" html-tag-alist))
         ;; Close the <p> tag and open on a new line.
         (p-tag-new `("p" \n ,(cdr (cdr p-tag-old)))))
    (add-to-list 'html-tag-alist p-tag-new)
    ;; Close the <code> tag and stay inline.
    (add-to-list 'html-tag-alist '("code"))))

(setq css-indent-offset 2)

For validation, grab css-validator.jar and execute it with java:

java -jar ~/.local/jars/css-validator.jar file:///home/me/my/site/index.html

(setq renz/org-home "~/.emacs.d/org/")

org-mode provides org-babel-tangle-jump-to-org, which jumps back to an Org source file from within the tangled code. renz/org-babel-tangle-jump-to-src, defined below, does the opposite - given the Org source file and point inside a src block, it jumps to the location of the tangled code. Provided by a helpful stackoverflow answer.

(defun renz/org-babel-tangle-jump-to-src ()
  "The opposite of `org-babel-tangle-jump-to-org'.
Jumps to an Org src block from tangled code."
  (interactive)
  (if (org-in-block-p)
      (let* ((header (car (org-babel-tangle-single-block 1 'only-this-block)))
             (tangle (car header))
             (lang (caadr header))
             (buffer (nth 2 (cadr header)))
             (org-id (nth 3 (cadr header)))
             (source-name (nth 4 (cadr header)))
             (search-comment (org-fill-template
                              org-babel-tangle-comment-format-beg
                              `(("link" . ,org-id) ("source-name" . ,source-name))))
             (file (expand-file-name
                    (org-babel-effective-tangled-filename buffer lang tangle))))
        (if (not (file-exists-p file))
            (message "File does not exist. 'org-babel-tangle' first to create file.")
          (find-file file)
          (beginning-of-buffer)
          (search-forward search-comment)))
    (message "Cannot jump to tangled file because point is not at org src block.")))

Now we configure org-mode itself. For a while I was trying (setq org-startup-indented t) to get indentation under each header, but this was interfering with the beautification features from org-modern. Preferring the latter over the former, I've removed the org-startup-indented call.

(defun renz/list-files-with-absolute-path (directory)
  "Return a list of files in DIRECTORY with their absolute paths."
  (cl-remove-if-not #'file-regular-p (directory-files directory t ".*\.org$")))
(use-package org
:hook
((org-mode . (lambda () (progn
(add-hook ‘after-save-hook #‘org-babel-tangle :append :local)
(add-hook ‘org-babel-after-execute-hook #‘renz/display-ansi-colors)
(setq indent-tabs-mode nil)))))
:init
(defun renz/jump-org ()
“Prompt for an org file in my emacs directory, then go there.”
(interactive)
(renz/–jump-section renz/org-home “Org files: " “.*.org$”))
:bind
((“C-c o a” . org-agenda)
(“C-c o b d” . org-babel-detangle)
(“C-c o b o” . org-babel-tangle-jump-to-org)
(“C-c o b s” . renz/org-babel-tangle-jump-to-src)
(“C-c o k” . org-babel-remove-result)
(“C-c o o” . renz/jump-org)
(“C-c o y” . ox-clip-image-to-clipboard))
:custom
(org-image-actual-width nil “Enable resizing of images”)
(org-agenda-files (renz/list-files-with-absolute-path renz/org-home) “Sources for Org agenda view”)
(org-html-htmlize-output-type nil “See C-h f org-html-htmlize-output-type”)
(org-confirm-babel-evaluate nil “Don’t ask for confirmation when executing src blocks”)
(org-goto-interface ‘outline-path-completion “Use completing-read for org-goto (C-c C-j, nicer than imenu)”)
(org-outline-path-complete-in-steps nil “Flatten the outline path, instead of completing hierarchically”)
:config
(add-to-list ‘org-modules ‘org-tempo)
(org-babel-do-load-languages
‘org-babel-load-languages
‘((emacs-lisp . t)
(python . t)
(sql . t)
(shell . t)
(R . t)
;; (fortran . t)
;; (julia . t)
;; (jupyter . t)
;; (scheme . t)
;; (haskell . t)
(lisp . t)
;; (clojure . t)
;; (C . t)
;; (org . t)
;; (gnuplot . t)
;; (awk . t)
;; (latex . t)
)))

When installing markdown through Anaconda, the executable is actually called markdown_py. In case markdown isn't found, use that instead.

(when (and (not (executable-find "markdown")) (executable-find "markdown_py"))
  (setq markdown-command "markdown_py"))

Some folks like to write markdown without hard line breaks. When viewing those documents, I can use M-x renz/md-hook to view it as if there were line breaks in it.

(defun renz/md-hook ()
  "View buffer in visual fill mode with 80 character width."
  (interactive)
  (visual-fill-column-mode)
  (setq-local fill-column 80))

I make a lot of spelling mistakes as I type…

(add-hook 'markdown-mode-hook 'flyspell-mode)
(add-hook 'markdown-mode-hook 'auto-fill-mode)

And I like to see language syntax highlighting within code fences.

(setq markdown-fontify-code-blocks-natively t)

These really should already be in auto-mode-alist, but aren't for some reason.

(add-to-list 'auto-mode-alist '("\\.rs\\'" . rust-ts-mode))
(add-to-list 'auto-mode-alist '("\\.go\\'" . go-ts-mode))
(add-to-list 'auto-mode-alist '("\\.ts\\'" . typescript-ts-mode))
(add-to-list 'auto-mode-alist '("\\.dockerfile\\'" . dockerfile-ts-mode))

Handy for viewing data quickly.

(use-package csv-mode
  :mode "\\.csv\\'")

I find it very distracting when eldoc suddenly pops up and consumes a large part of the screen for docstrings in python.

(setq eldoc-echo-area-use-multiline-p nil)

By default, dired uses bytes instead of "K", "Mb", or "G" for file sizes. I also have it hide the mode, size, and owner of each file by default.

(use-package dired
  :hook (dired-mode . dired-hide-details-mode)
  :config
  (setq dired-listing-switches "-alFh")
  (setq dired-dwim-target t))

Also enabled above is Do-What-I-Mean (DWIM) copying. This is for when two dired windows are open, and we want to copy something from one location to the other. By enabling dired-dwim-target, it auto-populates the minibuffer with the other dired window's path when issuing a copy command with C.

For visual lines, this adds line breaks at the fill-column value. Especially useful for prose that is meant to be copied to other mediums, such as email or word.

(use-package visual-fill-column
  :config
  (add-hook 'visual-line-mode-hook #'visual-fill-column-mode))

Ecosia requires JavaScript, unfortunately.

(use-package eww
  :config (setq eww-search-prefix "https://duckduckgo.com/html/?q="))

Often used when changing up my init.el.

(use-package restart-emacs
  :bind ("C-c x r" . restart-emacs))

As of version 29, eglot (Emacs polyGLOT) is bundled with Emacs. It provides Emacs with the client side configuration for the language server protocol.

(use-package eglot
  :bind (("C-c l c" . eglot-reconnect)
         ("C-c l d" . flymake-show-buffer-diagnostics)
         ("C-c l f f" . eglot-format)
         ("C-c l f b" . eglot-format-buffer)
         ("C-c l l" . eglot)
         ("C-c l r n" . eglot-rename)
         ("C-c l s" . eglot-shutdown)))

To have eglot always start up for a python buffer, we would tangle this line into init.el. However, this can cause a significant loading delay over Tramp, and I would prefer snappy, simple access with LSP provided on an as-needed basis.

(add-hook 'python-mode-hook 'eglot-ensure)

Tramp (Transparent Remote Access Multiple Protocol) allows us to access files on a remote machine, and edit them locally. This is great for simple changes or quickly testing out some Python on a VM somewhere. It isn't as snappy as using the TTY version or an X-forwarded Emacs from the server directly, so if I can set up Emacs remotely, I usually do. When I don't want to or don't have the time, Tramp is a godsend. There are, however, many foibles to guard against, particularly with how interacts with version control and .dir-locals. The Tramp manual (distributed with Emacs) recommends adjusting these for some speed improvements:

(use-package tramp
  :defer t
  :config
  (setq vc-handled-backends '(Git)
        file-name-inhibit-locks t
        tramp-inline-compress-start-size 1000
        tramp-copy-size-limit 10000
        tramp-verbose 1)
  (add-to-list 'tramp-remote-path 'tramp-own-remote-path))

eglot is actively working on an issue related to timers causing a "Forbidden reentrant call of Tramp" message and freezing. In the meantime, this setting was recommended.

(setq tramp-use-ssh-controlmaster-options nil)

For some time I was having a lot of trouble with prohibitive slowness over Tramp, and after careful scrutiny of the logs on (I believe) tramp-verbose 6, I found out that enabling remote dir-locals was causing a huge bottleneck. On every operation it would trace up the filesystem tree back to the root directory, scanning for a .dir-locals file. Since some of the drives were network-mounted, this caused thousands of network calls per file operation, obviously slowing things down a lot. Because of this, I've opted to simply disable .dir-locals over Tramp entirely, since I don't really use it much, if at all.

;; (setq enable-remote-dir-locals t)

Disabling VC does seem to speed things up a little, but it's not an acceptable thing to put in, since I so frequently use VC over tramp. Fully disabling VC would include this snippet:

(remove-hook 'find-file-hook 'vc-find-file-hook)
(setq vc-ignore-dir-regexp
(format “\(%s\)\|\(%s\)”
vc-ignore-dir-regexp
tramp-file-name-regexp))

Additionally, these came up as other potential options from the doom-emacs issues, which I do not currently include.

(setq tramp-default-method "scp")
(setq projectile--mode-line "Projectile")

I often need to set these in ~/.ssh/config for TRAMP to speed up

Host *
     ControlMaster auto
     ControlPath ~/.ssh/master-%h:%p
     ControlPersist 10m
     ForwardAgent yes
     ServerAliveInterval 60

The Async command buffer's default behavior is to print ^M characters (the carriage return) instead of actually clearing text. This is problematic for spinners and progress bars, so I have a little hack to work around that.

(defun renz/async-shell-command-filter-hook ()
  "Filter async shell command output via `comint-output-filter'."
  (when (equal (buffer-name (current-buffer)) "*Async Shell Command*")
    ;; When `comint-output-filter' is non-nil, the carriage return characters ^M
    ;; are displayed
    (setq-local comint-inhibit-carriage-motion nil)
    (when-let ((proc (get-buffer-process (current-buffer))))
      ;; Attempting a solution found here:
      ;; https://gnu.emacs.help.narkive.com/2PEYGWfM/m-chars-in-async-command-output
      (set-process-filter proc 'comint-output-filter))))
(add-hook ‘shell-mode-hook #‘renz/async-shell-command-filter-hook)

There might be a better way, but this mostly works for now.