It turns out that if you call Dired from Elisp, you can pass it a list of files to display. Protesilaos Stavrou (Prot) leveraged that fact to write a bit of Elisp that provides him with a flat list of files matching a regular expression in a specified directory structure. His post has the code so you can see how he did it but it’s mostly what you’d expect: after some setup, he calls directory-file-recursively to gather the list of files that he then passes on to Dired.

It’s a pretty nice system but after using it for a while, Prot realized that when he was dealing with large directories a bit of initial filtering of the most recently modified files would be useful. He solved that by adapting his previous code to do the filtering. He does it by taking the list of files from his first function and running them through seq-filter to get the files he’s interested in. Again, all the code is in his post but Prot says he won’t be updating the post so you should check out his configuration for the latest version.

If you frequently generate Dired listings and would prefer to deal with a flat list of the files without worrying about what directory they’re in, take a look at Prot’s post for an excellent solution.

Wow, I’m so good at overcomplicating things, I already made you go “huh?!” with the title alone! I have some mad skillz!

On with the show:

In the last couple of weeks, I slowly improved and tinkered with my Linux environment (Kubuntu). I’m not sure if it was a single thing that nudged me to do that, but between installing the latest version of Harper and switching to Vivaldi with its great features I keep discovering, I also started using denote-journal.

Denote-journal, from the prolific Prot who also made Denote, was something I wanted to try for a while. I didn’t really have a good reason to, because I’ve been using Journelly for a long time, and on my Mac or Linux desktop, I’d call a capture template that would append to the file, adding my additional entries.

But I always had one major issue with journaling on my iPhone: privacy. My iPhone is owned and regulated (with a system profile) by my workplace. So even if I’m fine writing personal notes on my Mac (I’m not, I’m iffy about it as well, I don’t trust Apple to respect my privacy much more than I trust Google), at the end of the day, these notes also sync to my iPhone.

On a day-to-day basis, for quick thoughts and work notes, Journelly and my iPhone are great, but when it comes to writing longer notes about my future plans, how I spent the weekend with my partners, and basically anything else that involves people whose privacy I respect, I always self-censor.

For this reason, I came up with a way to create private notes with Denote only on Linux. These notes only live on my Linux Desktop, with a few of those syncing to my Android¹ (again, not great, but at least it’s not work-managed).

I always feel more like myself on Linux because I am more myself - whether it’s customizing my shortcuts and workflow exactly how I like it, or if it’s the built-in privacy that can be further fortified and inspected. Journaling on Linux, without the world’s biggest nanny peeping over my shoulder, is where I really open up and write my most personal thoughts.

A couple of times I looked at my Journelly notes, those that I wrote on the Mac where I could write at length and use the full power of Emacs, and compared them to my older journal on Linux. Well, there is no comparison. And while creating a private note in Denote in Linux and linking it back to the original works², it introduces friction that hinders the flow of my thoughts.

So I looked into denote-journal, realized it’s very easy to use, and gave it a try one day, and since then:

Essentially, it’s what I used to do when I started using Journelly: refile my Journelly headers into my journal files when I get the chance. Or, as a matter of fact, I use org-refile-copy, which does exactly what it says, because I want to keep the original in Journelly. Since I now use individual journal files instead of a big file split into weeks (as I did in the past), this process is even easier. The only catch is the images.

Images in Journelly are saved in its /Journelly.org.assets folder, where my journal files can’t see them directly; and even if it did, these images are too big and cause freezes, and also oriented the wrong way, so they need at least a minimal treatment. For these reasons, I attach each image to the correct header in the journal daily file which I moved over from Journelly.

These journal notes are fantastic. I have my quick notes from the day available, but when I want to extend, all I do now is just write a new entry for that day (which looks just like the Journelly entries) and write to my heart’s content. There’s also a bonus: denote-journal allows me to make up for days if I didn’t create a “meta journal note” for the day (so far this happened only once) directly from the calendar, so if I miss a day, I go to the calendar, point at the missing day, and use denote-journal-new-or-existing-entry to take care of things. If I already have an entry, it jumps to it; if I don’t, it creates one.

Between my journal on Linux, the emails I write to other bloggers, my blog posts, and the occasional instructions I write in Denote, I think I write more than I did in my entire life. I’m thinking I need to start capturing it in some sort of book, though I have no idea what it will be about and how to edit my writings in a way that makes sense. This is only a vague concept at the moment.

Footnotes

¹ : I keep skirting around this issue so I’ll just mention it quickly: I used GrapheneOS in the past, and it’s great for these kinds of things, but GrapheneOS protects your phone to an extent that certain apps don’t work.

² : I’ve been doing this often enough that I have a whole tag in Denote called “supplemental” with additional thoughts and notes. In Journelly, I was just linking to those, and writing something like “I have more to say about this” and this would include a Denote link to the Linux-only note.

I've released blogmore.el v5.3.0. This is a pretty small release but adds a command I realised I'd forgotten to add a couple of releases ago.

Now that BlogMore has the concept of a post series, and now that blogmore.el lets you add and remove a series from a post, it makes sense that I'd want to link to a series in a post from time to time, like I can and do with categories and tags.

So v5.3.0 adds a blogmore-link-series command. It can also be found in the transient menu.

Emacs features have a discoverability problem, and we’re chipping away at it one demo at a time. The years since I wrote the last one of these have yielded several more surprising and useful finds, so it’s time again for another “batteries included” report.

If you’re a new Emacs user, don’t start here. This is not a getting-started guide. You will be better served by grokking basic Emacs concepts and sticking to the most widely recommended packages. Once you’ve experienced the Emacs equivalents of thoughts like “Why didn’t anyone think to put wheels on luggage until 1990?”, this series might be more helpful. My rule of thumb is that if you aren’t yet aware of undo-in-region, there is much low hanging fruit for the picking, and you can come back to this article after that supply has run out! .

Veteran Emacs users tend to use some relatively niche Emacs features, but in my experience it’s always a different subset for each user. So if you’ve been around the block a few times, I promise there will still be surprises below for you as well!

Same rules as before:

• No packages, stock Emacs only

• No steep learning curves. Learn each feature in under five minutes or bust.

• No gimmicks. No doctor, tetris, snake, dunnet, zone, butterfly… yes, we know about dissociated-press. Let’s move on.

• Just the deltas. No commonly mentioned packages like Flymake, doc-view, outline-minor-mode, gnus or eww. Nothing that Emacs brings up automatically or a nonspecific Google search gets you.

• Assume a modern Emacs, 28.1+.

  Also, if you’re new to Emacs and still reading:

  Emacs jargon	Modern parlance
  M-x	Alt + x
  C-x	Ctrl + x
  Frame	Emacs window
  Window	split/pane
  Buffer	Contiguous chunk of text/data
  Point	Cursor position in buffer
  Active Region	Text selection
  Region	Text selection (not highlighted)
  Face	Font, color and display properties

  I’m Sorry.

Okay? Let’s go:

Dictionary on hover (M-x dictionary-tooltip-mode)

Turn on dictionary-tooltip-mode to see word meanings in tooltips when you hover over them:

Of course, tooltip-mode will need to be enabled as well, but that’s the default.

If you have local dictionaries set up, it will try those first. Note that Emacs’ dictionary can look up contemporary jargon and lingo too, usually via Wiktionary:

find-file and dired with wildcards

A surprisingly little known utility of two of the most used Emacs commands: you can use wildcards when using both find-file and dired interactively.

• When finding files with find-file (C-x C-f), open multiple files at once with a wildcard like *foo*.txt.
• When opening a directory with Dired, produce a custom listing of specific files by specifying a filename wildcard.

Here’s a demo where both features are used to clean up some (very) old TeX compilation artifacts and then open a bunch of LaTeX files at once:

The fact that this is possible when calling them programmatically is evident from their function signatures. But realizing that this capability is also available during interactive use requires reading through the full docstring, and no one has the time for that!

In practice the Dired wildcard capability is superseded by a modern workflow like consult-find exported as a Dired buffer by embark-export, but this works out of the box.

List all URIs with M-x ffap-menu

Alternatives: fancy-urls-menu, my/search-occur-browse-url and co

You might be familiar with Emacs’ “find-file-at-point” feature, M-x ffap, that checks if the cursor is on a valid file path and offers to open it.

This is accompanied by ffap-menu, a less well known but equally handy command. ffap-menu scans the whole buffer for anything that looks like a file path or URL and presents you with all of them:

Since it offers a completing-read interface, this opens up a small universe of possibilities: you can export the list of (possibly filtered) completions into a buffer, copy or open all or any subset of them, or otherwise act on them right away with Embark.

Addendum: Listing propertized links

Many Emacs applications (like EWW) include URLs as text properties and not plain-text links, and ffap-menu misses them. Inspired by ffap-menu, I use a home-brew version that fetches such links as well.

The enhanced version:

(defun my/search-occur-browse-url (&optional use-generic-p)
  "Point browser at a URL in the buffer using completion.
Which web browser to use depends on the value of the variable
`browse-url-browser-function'.

Also see `my/search-occur-url'."
  (interactive "P")
  (let ((match nil)
        (match-data nil)
        (context
         (lambda (beg &optional shrp)
           (let* ((before (string-replace
                           "\n" ""
                           (buffer-substring-no-properties
                            beg (max (line-beginning-position) (- beg 30)))))
                  (link (string-replace
                         "\n" "" (buffer-substring-no-properties beg (point))))
                  (after (buffer-substring-no-properties
                          (point) (min (line-end-position) (+ (point) 30)))))
             (concat (propertize " " 'display '(space :align-to 65))
                     (propertize (concat "…" before) 'face 'shadow)
                     (if shrp
                         (propertize link 'face '(:inherit shadow :weight bold
                                                           :underline t))
                       link)
                     (propertize (concat after "…") 'face 'shadow))))))
    (save-excursion
      (goto-char (point-min))
      (while (search-forward-regexp my/search-url-regexp nil t)
        (push (cons (match-string-no-properties 0)
                    (funcall context (match-beginning 0)))
              match-data))
      (goto-char (point-min))
      (while (setq match (text-property-search-forward 'shr-url nil nil))
        (push (cons (prop-match-value match)
                    (funcall context (prop-match-beginning match) 'shrp))
              match-data)))
    (let* ((completion-extra-properties
            `(:annotation-function
              ,(lambda (cand) (concat " " (cdr (assoc cand match-data))))))
           (url (completing-read "Browse URL: " match-data nil t)))
      (if use-generic-p
          (browse-url-generic url)
        (browse-url url)))))

Compare windows (M-x compare-windows)

There are more commands for comparing buffers and files in Emacs than you can shake a stick at: there’s diff, diff-buffers, diff-backup, diff-buffer-with-file, dired-diff, vc-diff, and a whole constellation of ediff-, ediff-merge- and ediff-directories- commands. I lost count at around twenty two, and can’t remember most of them.

But my favorite diff command is the lightweight compare-windows, which does something very obvious and simple in a context-agnostic way.

It compares the text of two windows starting from their respective cursor positions, and stops at and reports the next mismatch. The two windows are the active one and whatever other-window would select. Obviously less powerful, but so much easier and faster to run than Ediff Have you tried ediff-regions-linewise? Setting this up is a four step process, involving selecting buffers, marking regions and calling exit-recursive-edit repeatedly, an advanced command that most Emacs users should never encounter! or diff:

compare-windows is only concerned with the actual text in the two windows, and not the provenance of this text. The buffer type, modification state, file, version-control status – all irrelevant! You can even compare a chunk of text in a buffer against another chunk a little further down in the same buffer by displaying it in both windows. In a silly yet effective way, it can even compare directory contents, including file attributes:

And yes, you can call it with a prefix argument to ignore whitespace differences.

compare-windows is what you use when you find yourself playing spot-the-difference between two views of any kind. It is my most used “diff” command.

Compare directories with Dired (M-x dired-compare-directories)

But speaking of comparing directories, Dired does (of course) provide a less hacky way to do that. M-x dired-compare-directories in Dired prompts for a directory to compare with, and marks all files whose names differ in both Dired listings. That covers the most common use case, and might be everything you need.

But we already did that with the rudimentary compare-windows. dired-compare-directories is an actual file-level comparison, so you can provide custom matching predicates involving any file attribute, like modification times or sizes. For instance,

• you can mark the more recently modified version of a file with (> mtime2 mtime1),
• or mark files with the same name but different sizes with (/= size1 size2)

In this example, dired-compare-directories has marked (i) files that are not common to the two listings and (ii) files with differing modification times:

Highlight buffer changes (M-x highlight-changes-mode)

While we’re on the topic of spotting differences, highlight-changes-mode is a handy way to emphasize changes to the file, and a “live” alternative to diff commands like diff-buffer-with-file:

Visualization with highlight-changes is determined only by the mode itself, and changes are highlighted from the time the mode is turned on until it’s turned off. In general, this is not what we want. What we would like instead is to highlight unsaved changes There is M-x highlight-compare-with-file, but this is non-ergonomic enough to the point of being unusable. . We could do this with some finesse, or just throw in a couple of hooks:

(defun highlight-changes-mode-turn-off ()
  (and highlight-changes-mode (highlight-changes-mode -1)))

(defun highlight-changes-auto ()
  (when (buffer-file-name)
    (highlight-changes-mode-turn-on)
    (add-hook 'after-save-hook #'highlight-changes-mode-turn-on nil t)
    (add-hook 'before-save-hook #'highlight-changes-mode-turn-off nil t)))

(add-hook 'text-mode-hook #'highlight-changes-auto)

Now all changes in text-mode buffers are automatically highlighted.

(require 'hilit-chg)
(defun highlight-changes-mode-turn-off ()
  (and highlight-changes-mode (highlight-changes-mode -1)))

(define-minor-mode highlight-unsaved-mode
  "Highlight all changes until the buffer is saved."
  :lighter "H"
  (cond
   ((not (buffer-file-name))
    (user-error "Highlight-until-save-mode is only meant for use in file-visiting buffers"))
   (highlight-until-save-mode
    (highlight-changes-mode 1)
    (add-hook 'after-save-hook #'highlight-changes-mode-turn-on nil t)
    (add-hook 'before-save-hook #'highlight-changes-mode-turn-off nil t))
   (t (highlight-changes-mode -1)
      (remove-hook 'after-save-hook #'highlight-changes-mode-turn-on t)
      (remove-hook 'before-save-hook #'highlight-changes-mode-turn-off t))))

Finally, highlight-changes-mode provides an auxiliary capability: you can jump to the next and previous change in the buffer with highlight-changes-next-change and highlight-changes-previous-change. Since this is an independent consequence of change tracking you can use just this navigation and turn off the change visualization with M-x highlight-changes-remove-highlight.

Actually useful file backups (vc-diff variants)

One last excursion to close out the theme of spotting and diffing changes.

This will require a tangent through the topic of Emacs backup files and is pushing both the five minute limit and the idea of a built-in, so please bear with me.

Let’s back up

By default, Emacs makes a periodic backup of any file you edit and save. This backup system is usually mentioned only in the context of being something annoying you should disable (via make-backup-files). If you want actual backups you could just use version control, right?

If you have security concerns with sensitive files being copied to elsewhere on disk, I sympathize. But otherwise, I think this is largely an ergonomics issue.

• Emacs litters your working directory with the backups, and
• doesn’t make it easy to peruse and work with the backup files.

Changing the former is a user option For example, see backup-directory-alist, kept-old-versions and kept-new-versions. , but the latter is entirely the case of a missing user interface.

The external package backup-walker provides this “time-machine” interface, along with a couple of others. But there is a simpler, satisfying fix available that simultaneously solves another problem.

VC (until V don’t)

Emacs’ built-in VC package offers an interface for viewing past versions of version-controlled files:

vc-diff (C-x v =)

Diffs the file against its immediate previous version, or against a prescribed version when called with a prefix argument.

vc-ediff

Runs Ediff against the file’s previous version, or against a prescribed version.

vc-revision-other-window (C-x v ~)

Displays a previous version (immediate or specified) of the file next to this one.

This is a handy interface and not git-specific, unlike magit’s versions of these commands. , but of course they do nothing in files that aren’t version controlled.

In the spirit of getting the most out of every fiber of muscle memory, we can extend the vc- interface for the purpose of inspecting backups as well.

The bridge

We can overload all three VC commands so they always do something useful in a file:

• If the file is unsaved, vc-diff (vc-ediff) generates a diff of (runs Ediff on) the buffer against the file.
• If the file is version controlled, run vc-diff (vc-ediff, vc-revision-other-window) as usual.
• If the file is not version controlled, diff against (Ediff, show) the latest numbered backup, or a prescribed numbered backup when called with a prefix argument.

This forces functions into a single consistent mental model:

Compare against the previous version, for whatever “previous” means in this context.

As a bonus, we are also free to forget about a few different diff commands that have been subsumed here, such as diff-buffer-with-file and ediff-current-file.

(defun my/read-backup-file-name (file)
  (if-let* ((backup-files (file-backup-file-names file)))
      (completing-read "Backup version: " backup-files nil t)
    (user-error "No backup files available for file %s" (buffer-file-name))))

(defun my/vc-diff (&optional arg)
  "Compare current buffer with its file, or file with backup or revision.
With prefix ARG, compare the file with a selected backup when the file
is not under version control."
  (interactive "P")
  (if (buffer-modified-p)
      (diff-buffer-with-file (current-buffer))
    (condition-case errdata (call-interactively #'vc-diff)
      (error
       (if (string-match-p "not under version control" (cadr errdata))
           (if arg
               (diff (my/read-backup-file-name (buffer-file-name))
                     (buffer-file-name))
             (diff-backup (buffer-file-name)))
         (apply #'signal errdata))))))

(defun my/vc-ediff (&optional arg)
  "Run Ediff on the current buffer, file, or backup.
With prefix ARG, compare the file with a selected backup when the file
is not under version control."
  (interactive "P")
  (if (buffer-modified-p)
      (call-interactively #'ediff-current-file)
    (condition-case errdata (call-interactively #'vc-ediff)
      (error
       (if (string-match-p "not under version control" (cadr errdata))
           (if arg
               (ediff-files (my/read-backup-file-name (buffer-file-name))
                            (buffer-file-name))
             (ediff-backup (buffer-file-name)))
         (apply #'signal errdata))))))

(defun my/vc-revision-other-window (&optional arg)
  "Visit the current file's past revision or backup in another window.
With prefix ARG, visit a selected backup when the file is not under
version control."
  (interactive "P")
  (condition-case errdata (call-interactively #'vc-revision-other-window)
    (error
     (if (string-match-p "not under version control" (cadr errdata))
         (if arg
             (find-file-other-window (my/read-backup-file-name (buffer-file-name)))
           (if-let* ((backup (file-newest-backup (buffer-file-name))))
               (find-file-other-window backup)
             (user-error "No backup files available for %s" (buffer-file-name))))
       (apply #'signal errdata)))))

See scroll all windows for a demonstration of the generalized vc-diff working with backup files.

The apropos family

If you only use one help keybinding, it should be C-h k, describe-key, since the very fact that every key press invokes a first-class function that you can live-inspect and mess with can be a revelation.

If you learn two, there is a strong case for apropos being the second. It bridges the gap between not knowing what to search for and getting a full picture of how things are laid out. It’s a foot-in-the-door command.

But you already know apropos. What’s less evident is that apropos is a whole family of commands that do increasingly specialized but useful look-ups It’s ironic that the extended apropos family is itself not very discoverable. .

Bind them all under C-h a, replacing apropos:

(defvar-keymap help-apropos-map
  :doc "Keymap for apropos subcommands."
  "a"   #'apropos
  "l"   #'apropos-library
  "f"   #'apropos-function
  "x"   #'apropos-command
  "v"   #'apropos-variable
  "V"   #'apropos-local-variable
  "u"   #'apropos-user-option
  "d"   #'apropos-documentation
  "C-f" #'customize-apropos-faces
  "g"   #'customize-apropos-groups
  "o"   #'customize-apropos-options
  "c"   #'customize-apropos
  "i"   #'info-apropos)
(keymap-set help-map "a" help-apropos-map)

My favorite of these is customize-apropos: it produces a bespoke customization buffer for perusing or changing all options matching the thing you searched for:

find-func goodies (M-x find-function-on-key, M-x find-function)

One of the most useful things you can do in Emacs, if you don’t like what a keybinding does (or if you’re simply curious), is to jump to the definition of the command it calls to see how to modify its behavior live. Normally this is a multi-step process:

1. Find the command invoked by the key: describe-key or C-h k + your key sequence.
2. Jump to its definition by pressing s (for “source”).
3. Get hacking or reading.

find-function-on-key obviates step 2, and takes you from keybinding to the source. Bind it to a key and you’re off to the races.

C-h M-k for me, as it’s a variation of describe-key:

(keymap-set help-map "M-k" #'find-function-on-key)

Going from a keybinding to the source of the function in one step is a minor shortcut for the common route, but it’s magical the first time you try it. No video demo, because the effect is so instantaneous a video would be both (i) confusing and (ii) underwhelming!

copy-from-above-command and duplicate-dwim

Emacs recently added some missing editing commands that have been part of most users’ tool-belts for decades. The two most useful of these are for duplicating text with the cursor as the destination and source. Respectively,

• copy-from-above-command copies text from the first non-blank line above the current one, similar to Vim’s C-y.
• duplicate-dwim copies text on the current line (or active region) below the current one, similar to Vim’s yy<N>p¹.

In typical Emacs fashion, slight tweaks can make these commands work how your brain does:

• copy-from-above-command copies as many characters from the above line as the prefix argument. I typically want to copy the whole line, so I change the prefix argument interpretation to “copy the above line and comment it out”, a very common action when experimenting with code or prose:

    (define-advice copy-from-above-command (:around (func &optional arg) comment)
      (if (equal current-prefix-arg '(4))
          (progn
            (funcall func)
            (save-excursion
              (forward-line 0)
              (let ((ln (line-number-at-pos (point))))
                (backward-char)
                (skip-chars-backward "\n\t ")
                (unless (= (line-number-at-pos) ln)
                  (comment-line 1)))))
        (funcall func arg)))
  

  Note that the original prefix argument behavior still works, you can copy a fixed number of characters from above with C-<N>.

• duplicate-dwim has a choice to make about where to place the cursor after the duplication: does the user mean to continue working with the duplicated text or the original?

  You can make that choice for yourself by setting a user option. I prefer to move the cursor and region to the duplicated text:

    (setq duplicate-region-final-position -1
          duplicate-line-final-position -1)
  

Turn keystrokes into macros (M-x kmacro-edit-lossage)

Three facts about Emacs keyboard macros:

1. They are far more powerful than many users realize See Mickey Peterson’s excellent article Keyboard Macros are Misunderstood . We tend to associate macros with text transformations, but they capture and playback any sequence of actions in Emacs, including mouse clicks. And since this is Emacs, actions don’t have to correspond to text editing at all. All the short video demos in this article were copied across Dired buffers, processed with FFmpeg, renamed and inserted into the draft using a single keyboard macro.
2. They require a lot of premeditation and focus to use. Unfortunately “thinking in macros” is cognitively taxing. Any error or non-generalizable movement can scupper the whole attempt. The multiple-cursors package and others like it present alternative interfaces to keyboard macros that lower the mental strain.
3. But they still don’t solve the “foresight” problem: I need to know before the fact that a sequence of actions will need to be repeatable, and start a recording. Coupled with the fact that you’re unlikely to get a complex sequence right the first time, we’re back to the previous problem again.

Vim’s . (dot) command is a solution here, since Vim is effectively always recording a macro of your edits, and Emacs’ dot-mode package emulates this with some success. But these are still limited to buffer edits, and not full fledged keyboard macros.

Well. Emacs provides the confusingly named kmacro-edit-lossage command that addresses this foresight problem, albeit in a manual way. At any time, you can view your “lossage”, a record of the last 300 or so key-presses with the view-lossage (C-h l) command.

kmacro-edit-lossage takes this further, and lets you create a macro from your key-press history at any time. The lossage is truly editable, you can and will want to insert new commands into the lossage when creating a macro. An example of creating a macro from a keystroke sequence that is setting up a window split:

“Oh, I need to do the complex thing I just did 200 times”

In practice, I edit macros I’ve already defined with edit-kbd-macro (C-x C-k e) more than I fashion new ones out of the lossage, but on the infrequent occasions that call for kmacro-edit-lossage, it’s a real lifesaver The editing process generally requires a generous sprinkling of kbd-macro-query calls into the lossage to be truly generalizable. .

subword-mode, superword-mode and word syntax

Emacs offers word-based navigation and editing commands (forward-word, forward-to-word, kill-word…) and major-mode-specific syntax tables, leaving the question of “what is a word?” up to you.

subword-mode and superword-mode are two different answers to this question. With subword-mode turned on, each component of a CamelCase symbol counts as a word. As the documentation helpfully illustrates:

  Nomenclature           Subwords
  ===========================================================
  GtkWindow          =>  "Gtk" and "Window"
  EmacsFrameClass    =>  "Emacs", "Frame" and "Class"
  NSGraphicsContext  =>  "NS", "Graphics" and "Context"

When superword-mode is turned on, snake_case symbols like this_is_a_symbol counts as one word The string-inflection package provides a command to easily cycle between these styles: this_is_a_symbol –> this-is-a-symbol –> This_Is_A_Symbol –> thisIsASymbol –> ThisIsASymbol. . In practice, this is less crucial than subword-mode, since acting on symbols is already well supported in Emacs via the *-sexp commands.

More generally, it can be worth taking a few minutes to modify the syntax table of a major mode to fix annoyances you might be experiencing with structural navigation. In Lisp-y contexts, my most useful change is to make “:” be considered part of a word, so that I can backward-kill-word through keywords like :foo:

(add-hook 'lisp-data-mode-hook
          (lambda () (modify-syntax-entry ?: "w")))

In Org mode, it’s treating the delimiters = and ~ as word constituents:

(add-hook 'org-mode-hook
          (lambda ()
            (modify-syntax-entry ?= "w")
            (modify-syntax-entry ?~ "w"))

See describe-syntax (C-h s) and modify-syntax-entry for how to specify the syntax of characters.

Manipulate image display

Almost everywhere that Emacs displays an image, you can manipulate the display by placing the cursor on the image and pressing i. Here is an example with images displayed in Elfeed (an RSS feed reader) and in Org mode:

I used the keyboard in this demo, but you could just use the C-<wheel> shortcut familiar from browsers and other applications.

The most useful bindings are i + and i - to zoom, and maybe i r to rotate the image by 90 degrees. But you can do other things like cropping the image with i c – see M-x describe-keymap⮐ image-map.

If you use repeat-mode, you don’t need the i prefix after the first invocation either, you can repeat with just +, - or r.

This functionality is provided via a keymap placed over images, and nothing needs to be turned on for this. Note that only the image display is modified, not the image on disk.

In web-pages and rendered-HTML buffers, there is one more useful command: pressing z (shr-zoom-image) will split the image into horizontal strips across several lines, and cycle through different image sizes. It’s an odd command, probably intended to mitigate Emacs’ display engine limitations when dealing with large images. But mitigate it does. Useful if you visit websites with huge images in Emacs.

Make all text visible (M-x visible-mode)

Emacs can make buffer text selectively invisible. Marking text as invisible is the basis of all “folding” behavior – think magit-section buffers, Outline mode, Org mode and so on. Every mode that provides folding also provides keybindings to toggle the fold state, and pressing TAB usually works. Usually.

In practice, these keybindings tend to be all over the place. For when you can’t be bothered to learn mode-specific conventions because you don’t use the mode enough Or because the interface is bonkers, like the default outline-minor-mode keybindings. and just want to see all hidden text, you’ve got visible-mode.

visible-mode is somewhat low-level, it simply disables text invisibility across the buffer until you call it again. So if the buffer is presenting a “reactive” UI where (un)folding text has dynamic effects, things can appear broken until you disable visible-mode. As such, it’s intended as a temporary measure or a debugging tool, but since it always works it’s my go-to button for showing all buffer text uniformly with one command.

Ignore visible text (isearch-toggle-invisible)

And speaking of visible-mode, some Emacs commands like Isearch ignore text invisibility out of the box, making it easy to search across the actual document text As usual, the full behavior is more complicated. Isearch also restores the invisibility when you move out of an invisible region that was temporarily revealed. .

But this behavior also has a downside. When the buffer as presented is intended as a guide, automatically revealing invisible text breaks our assumptions about what Isearch will do. This is a problem when using Isearch as a navigation (and not a search) tool.

You can toggle searching invisible text when using Isearch with isearch-toggle-invisible, bound to M-s i when searching:

This keybinding is not arbitrary – all the Isearch behavior toggles are under the M-s keymap, mirroring Isearch’s default binding of C-s. (But that’s a whole article unto itself.)

Ruler (M-x ruler-mode)

At some point in its eventful past, Emacs was intended to possess WYSIWYG word-processing features. This is not surprising, it’s difficult to find computing applications that Emacs doesn’t implement in its own janky, special way.

One of the byproducts of this ambition is that there are some semi-buried WYSIWYG features lingering around. The center- commands are one such feature, centering lines, paragraphs and regions relative to fill-column. Useful for fancy comments in code… and not much else, unless you like to print from Emacs buffers.

But customizable display margin and fringe widths are a welcome addition, as a lot of functionality can be stuffed into this screen estate. The only problem with specifying widths like margins is actually doing it. You might think that the handily named set-left-margin and set-right-margin commands do this, but they actually work like the center commands, indenting the actual buffer text. It’s surprisingly messy. There is no direct command for this, and setting the display margins does not take effect until the window is displayed again.

ruler-mode has you covered:

As a bonus you can set the fill-column too. You can also set the goal column, but that’ll have to wait. Of course, you could use the visual-fill-column or olivetti packages for this, but if you like to change the margins instead of toggling between preset widths, ruler-mode is arguably even more user-friendly.

Refill text (M-x refill-mode)

On the theme of text widths, Emacs provides a handy series of fill- commands and an auto-fill-mode for filling text as you type.

The fact that auto-fill-mode features prominently in Emacs’ tutorial, among the first things you’re expected to learn, suggests that Emacs takes text filling very seriously, considering it a crucial text-editing feature.

Personally, the only people I know devoting any of their attention to text widths on computer screens are professional typesetters… and some Emacs users. If you’re reading this you might be one of them, so I ask you: isn’t it odd that auto-fill-mode is not actually automatic? It only wraps the line you’re on, leaving any earlier misalignment in the paragraph (caused by pasting text from elsewhere, say) to be fixed manually.

refill-mode is Emacs’ actual automatic text-filling feature. It ensures that your document stays wrapped at the fill-column:

M-x refill-mode and you’re set.

Scroll all windows (M-x scroll-all-mode)

There are two commonly recommended scroll-related commands that new Emacs users find surprising, in the sense that they make you wonder why other software doesn’t have them.

The first is scroll-other-window, for scrolling the window that isn’t selected without having to switch to it first. This is very handy when the next window contains material that’s a reference for our work in this one. The second is follow-mode (covered in an earlier installment), giving you a contiguous view of a single buffer across multiple windows.

scroll-all-mode is almost as useful, but lesser known than these two. This mode scrolls all windows on the frame simultaneously: very handy when you’re looking at buffers that need to be “synced” in some way. A common use for me is eyeballing two versions of a file without having to get locked into an Ediff session:

It’s just M-x scroll-all-mode.

Bonus: scrolling other windows and master-mode

While we’re on the topic of scrolling other windows, a common question is what happens if you have more than two windows on screen, and the window you want to scroll is not the “next-window” that Emacs picks This tip is recycled from The Emacs Window Management Almanac, but I wouldn’t blame you for missing it in the 15,000 word sea of blather. .

One solution is the built-in master-mode, where you can pre-designate (or live-designate) buffers that should be scrollable from other buffers.

But a more immediately useful method is to set the strategy used to find the window to scroll. One option is

(setq other-window-scroll-default #'get-lru-window)

which will always scroll the least-recently-used window. This is useful if the window you want to scroll contains reference material that you won’t be editing, so the window will rarely be selected.

Alternatively, you might have two windows (of many), both of which see frequent edits. You’d then use the most-recently-used window as the other window to scroll:

(setq other-window-scroll-default
      (lambda ()
        (or (get-mru-window nil nil 'not-this-one-dummy)
            (next-window)               ;fall back to next window
            (next-window nil nil 'visible))))

Some combination of these should make scroll-other-windows always do-what-I-mean.

Refuse to terminate (M-x emacs-lock-mode)

If you try to quit Emacs with unsaved files, Emacs refuses until you answer the question of what to do about each of them. Annoying perhaps, but a useful check.

emacs-lock-mode extends this idea and hands you the controls. Call it in any buffer to “lock” it.

Until the lock is disengaged, the buffer will refuse to be killed, throwing up a message instead:

Buffer "*scratch*" is locked and cannot be killed

and Emacs will refuse to exit:

Emacs cannot exit because buffer "*scratch*" is locked

This is handy for non-file-visiting buffers containing information you don’t want to accidentally lose, or just as a reminder that a task in that buffer is pending, and you shouldn’t throw away the context.

In a post Org-capture world, the former is rarely an issue, but locking is still useful in shell and compilation buffers, websites or other special applications that contain output or state you don’t want to lose.

Undelete frames (M-x undelete-frame-mode and M-x undelete-frame)

If you accidentally close an Emacs frame with a carefully curated workspace, M-x undelete-frame has your back. Uh, if you’ve turned on undelete-frame-mode, that is.

It does exactly what the more widely recommended (also built-in) winner and tab-bar-history packages do, but for frames instead of windows. Turn on undelete-frame-mode with your Emacs and don’t worry about closing frames again. It can restore up to the last 16 deleted frames.

The leftovers

That’s twenty Emacs features I collided with in the last six years that have survived contact with the reality of using Emacs in 2026. Several more Emacs libraries I discovered by fat-fingering the keyboard ended up being more interesting as archaeological artifacts than as reliable solutions to common user needs. allout-mode is Org mode from a parallel universe, an outline manager with features like Org’s speed-keys and even per-subtree encryption. shadowfile is implementing unison from inside Emacs, with questionable utility. double-mode is a key-translation-based input-method for typing non-keyboard characters that predates quail. The bs library was someone’s attempt at a smarter list-buffers command, but ibuffer blew everything else out of the water so there’s no reason to use it.

Other ostensibly handy features, like wrapping regions with delimiters using electric-pair-mode, didn’t make the cut because the ratio of finickiness to utility is too high. It’s better to just use an external package like wrap-region, smartparens or embrace for this.

Then there’s the constellation of included Org and Org-adjacent libraries (like appt) that add interesting but obscure features to Org mode. But that’s a whole story by itself, best covered in a dedicated article.

Finally, a lot of my serendipitous finds were libraries new and old that are primarily of interest to Elisp developers. The thunk library is an example of this. These too deserve their own write-up.

Still, I hope you found at least a couple of useful tips among the batteries that passed testing. The lisp directory that ships with Emacs isn’t that big, but somehow this barrel never runs dry. I don’t doubt that more batteries remain to be found, even if it takes a few more years of typos to stumble onto them. Until then, happy Emacsing!

By pure coincidence, it's six years ago tomorrow that I finally, after years of running Emacs with a bright white background, moved to using a dark theme. It took a little bit of getting used to but eventually I got very comfortable with it, and since then have run everything I can in a dark mode too.

On occasion, in the last year or so, I've had this urge to move to something darker. Also, in part, it's an urge to change things up a little. I felt it was time for a refresh of how my Emacs looks. I've tried a few themes, but none have ever stuck. When trying them I've run into various issues:

• It just didn't look nice at all
• Too many other things I use in Emacs didn't get themed
• It looked like there was going to be too much work to do to really theme things well
• It caused Emacs to crash¹

However, yesterday evening, after making an effort to simplify my mode line, I was determined to find a darker theme that I would be happy with. I think I finally managed!

I've settled on modus-vivendi from modus themes. Out of the box it felt right, and from what I can see in the documentation there's an amazing amount of customisation you can do. The key point there too is the documentation; there's so much of it, it's incredibly comprehensive.

For example: the default choice for the mode line is to have an unsubtle border around it -- presumably to create a good contrast. I found that far too distracting and was wondering what I could do about it. I didn't have to wonder long, the documentation addresses exactly that situation.

Another downside I ran into is that the colours that were showing in the mode line, when I switched to mood-line yesterday, were gone. I spent a short amount of time last night, and a good hour or so this morning, trying to wrangle mood-line into something I liked, but I just couldn't get anything sensible going. Eventually I cracked, fired up Antigravity, prompted it with:

I am using mood-line for my mode line -- see init.d/packages.d/melpa/mood-line.el and https://github.com/emacsmirror/mood-line

I am using https://protesilaos.com/emacs/modus-themes as my theme

I would like to have finer control over the parts of the mode line I've configured. For example, I'd like the buffer name to stand out in an informative colour, but one that is part of the modus theme's colour scheme.

Don't make changes yet, but help me understand how I should do this in a maintainable way.

and then spent about 20 minutes going back and forth, refining what I wanted; this got me a result I'm happy with from a visual point of view. I still need to fully review the code and the approach it took, but it isn't too far removed from what I'd been trying myself.

Overall I'm pleased with the result, and this is the longest I've stuck with a new theme (at this point I'm probably about 4 or 5 hours into working in it). I think that says something significant. I can see myself still wanting to tweak some aspects of it though. For example, the left-hand fringe doesn't feel quite right, in a way I can't quite put my finger on. While I want it to stand out from the main editing area, it feels... disconnected in some way. Also the background colour of the mode line still feels like it doesn't quite blend how I'd like.

Now to see if this lasts...

When we call dired from Lisp, we can pass it a list of files instead of a directory. This gives us a fully fledged Dired buffer for those files. My most common use-case is to produce flat listing, so that I do not have to go searching in exactly which directory some file is (e.g. in the Downloads folder there is some zip archive that I downloaded with a bunch of files in a complex structure).

A flat Dired listing

For a while now I have been using my own command to create a Dired buffer from the current directory (which can always be updated on demand with M-x cd). It is prot-dired-search-flat-list. Here is the code:

(defvar prot-dired-regexp-history nil
  "Minibuffer history of `prot-dired-regexp-prompt'.")

(defun prot-dired-regexp-prompt ()
  (let ((default (car prot-dired-regexp-history)))
    (read-regexp
     (format-prompt "Files matching REGEXP" default)
     default 'prot-dired-regexp-history)))

(defun prot-dired--get-files (regexp)
  "Return files matching REGEXP, recursively from `default-directory'."
  (directory-files-recursively default-directory regexp nil))

;;;###autoload
(defun prot-dired-search-flat-list (regexp)
  "Return a Dired buffer for files matching REGEXP.
Perform the search recursively from the current directory."
  (interactive (list (prot-dired-regexp-prompt)))
  (if-let* ((files (prot-dired--get-files regexp))
            (relative-paths (mapcar #'file-relative-name files)))
      (dired (cons (format "prot-flat-dired for `%s'" regexp) relative-paths))
    (error "No files matching `%s'" regexp)))

I could modify prot-dired-search-flat-list to also prompt for a directory, though I optimise for the common workflow of operating from where I am (and I generally do not like overloading the C-u with special cases that I will never remember—a new command with a name I can search for is better).

Flat listing limited to last modified since DAYS

Yesterday I had the need to browse a massive directory, but only wanted to get a couple of files out of it. I realised that I had to filter my last modified, so I extended my above use-case with the new command prot-dired-search-flat-list-since-days. Here is what I came up with:

(defvar prot-dired-days-prompt-history nil
  "Minibuffer history for `prot-dired-days-prompt'.")

(defun prot-dired-days-prompt ()
  "Prompt for days and return them as a number."
  (let* ((first (car prot-dired-days-prompt-history))
         (default (when (stringp first)
                    (string-to-number first))))
    (read-number "Number of days: " default 'prot-dired-days-prompt-history)))

(defun prot-dired--get-last-modified (files days)
  "Return list of FILES last modified since DAYS."
  (seq-filter
   (lambda (file)
     (and-let* ((attributes (file-attributes file))
                (last-modified (nth 5 attributes))
                (last-modified-seconds (time-to-seconds last-modified))
                (current-time (current-time))
                (current-time-seconds (time-to-seconds current-time))
                (delta-seconds (* days 24 60 60))
                (oldest-seconds (- current-time-seconds delta-seconds))
                (_ (>= last-modified-seconds oldest-seconds)))))
   files))

;;;###autoload
(defun prot-dired-search-flat-list-since-days (regexp days)
  "Return Dired buffer with files matching REGEXP up to DAYS since last modification.
Perform the search recursively from the current directory."
  (interactive
   (list
    (prot-dired-regexp-prompt)
    (prot-dired-days-prompt)))
  (if-let* ((files (prot-dired--get-files regexp)))
      (if-let* ((files-filtered (prot-dired--get-last-modified files days))
                (relative-paths (mapcar #'file-relative-name files-filtered)))
          (dired (cons (format "prot-flat-dired since %d days for `%s'" days regexp) relative-paths))
        (error "No files last modified within the last %d days" days))
    (error "No files matching `%s'" regexp)))

Note that I always design my minibuffer prompts to have their own history, because then I only get relevant entries when I press M-p (previous-history-element) and M-n (next-history-element) at the prompt (and the built-in savehist-mode takes care to persist those).

Everything is part of my Emacs configuration: https://protesilaos.com/emacs/dotemacs. I will not be updating this article, so make sure to check for any further refinements there.

Every so often I get the urge to change how Emacs looks. Ever since I finally fell to the dark side, my Emacs has stayed looking pretty much the same. I like how it looks, but I do keep having this urge to find a darker theme, and to also make things just a wee bit more minimal.

At one point I was very much about, and in favour of, having as much information as possible in the mode line. Eventually I realised I didn't use that much and tried to declutter somewhat, mostly cleaning up minor mode information with diminish. Even then though, I had this feeling that there was still more information in the mode line than I really needed.

So, just now, as an experiment, I've decided to start fairly clean. I've dropped powerline and instead decided to have a play with mood-line. Rather than use one of its pre-configured formats, I've had a go at rolling my own:

(setq mood-line-format
      (mood-line-defformat
       :left
       (((mood-line-segment-buffer-status) . " ")
        ((mood-line-segment-buffer-name) . " : ")
        (mood-line-segment-major-mode))
       :right
       (((mood-line-segment-vc) . "  ")
        (mood-line-segment-cursor-position))))

So far I'm really pleased with the result.

For any given buffer the mode line display is now:

• The status of the buffer
• The name of the buffer
• The major mode of the buffer
• The git status for what I'm working on
• The cursor position

Honestly, I'm struggling to think of anything else I really need to see. Sure, I can imagine there's the odd minor mode I might need to know about, but generally I either have them enabled all the time anyway, or it's something so obvious that I know when it's not enabled.

I'm going to run with this for a while now and see how I feel. I can sense that I might want to tweak a couple of things (at the moment the left-hand side will move when I change the unsaved status of the buffer; on the right there's nothing that tells me that this file I'm editing right now is new to the repo and not part of it yet), but this basic configuration feels clean and right.

Meanwhile... the search for a theme that is darker and I actually prefer over the sanityinc-tomorrow themes continues. I fear this is going to be a lot harder.

Bozhidar Batsov has a post announcing a couple of new Emacs modes for AsciiDoc. In the usual Batsov way, he’s significantly improved the support for AsciiDoc in Emacs. He loves AsciiDoc but found it hard to use in Emacs because the support was so bad.

I’ve never used AsciiDoc so I don’t know why Batsov prefers it to Org mode. Org mode can be and has been used to produce first class technical documentation. If needed, it can bring to bear all the power of LaTeX to produce a polished product.

As far as I can see, the only reason not to use Org mode is because you’re not an Emacs user or are collaborating on a document with someone who isn’t. It offers everything you’re apt to need short of bringing in a heavyweight dedicated document preparation system. I’m sure Irreal readers not as ignorant as I about the situation can tell us why we should prefer AsciiDoc. Our lines are open.

If you are an AsciiDoc user, Batsov’s two new modes are sure to be a blessing. The update to adoc-mode is designed to work with all versions of Emacs and updates the regex-based font-locking to the current AsciiDoc grammar. It’s perfect for an AsciiDoc user who’s running an older version of Emacs. Asciidoc-mode is the more modern solution using tree-sitter to handle things like font-locking but it only runs on Emacs 30.1+.

Take a look at Batsov’s post for the details on the two modes. And if you know why an Org mode user should care, leave a comment.

Another quick update to blogmore.el, again to fix an issue I've run into with the new frontmatter-handling code. This time it's to address an actual crash that could happen if a property was available but empty. For example, if a post had frontmatter that looked like this:

title: "blogmore.el v5.2.0"
date: "2026-06-12 08:31:15+0100"
category: Emacs
tags:

And I then went to use blogmore-add-tag, I'd get a crash saying:

Wrong type argument: sequencep, :null

The reason being that tags was being parsed with a value of :null, rather than (as before) having a value of nil (which of course meant I had a nice empty list to do things with). It was an easy enough fix.

At this point I think I've managed to shake out any serious issues with the proper YAML-parsing approach to frontmatter, as I've used it to write a handful of posts now.

A quick little update to blogmore.el to fix a couple of issues introduced by the new YAML-parsing approach to reading frontmatter; both pretty much stemming from how falsy values are handled.

Simply put, both boolean false values, and also empty values (something that could commonly happen with tags and series) would end up showing up in the frontmatter as null. This release handles that situation.

Also, under the hood, I cleaned up some repeated boilerplate related to how the cached dump calls to BlogMore took place. The code for categories, tags and series data was almost exactly the same, save for the actual name of the thing being dumped. So I turned it all into a macro:

(defmacro blogmore--cache-dump (dump-name)
  "Generate a function to get DUMP-NAME from BlogMore, with caching."
  (let ((cache-name (intern (format "blogmore--current-%s-cache" dump-name)))
        (getter-name (intern (format "blogmore--current-%s" dump-name))))
    `(progn
       (defvar ,cache-name nil
         ,(format "Cache for the list of %s from existing posts." dump-name))
       (defun ,getter-name ()
         ,(format "Get a list of %s from existing posts." dump-name)
         (or ,cache-name (setq ,cache-name (blogmore--list-of ,(symbol-name dump-name))))))))

and now the defvar that creates the variable that holds the cache, and the defun that creates the getter function for the data, are reduced to this for all three collections of values:

(blogmore--cache-dump categories)
(blogmore--cache-dump tags)
(blogmore--cache-dump series)

Sure, I probably could have done all of this in a single global, a central getter function, and a hash table, but the macro approach feels so much more elegant, and more... lispy.

And it’s understandable — things are getting worse and worse all the time, and anybody who is running a web site (that has interesting information) is under constant attack from badly programmed AI scrapers.

But where does that leave us li’l smol peeps who are just scrapin’ a li’l data for ourselves so that we don’t have to type as much?

I’ve got two small use cases that have been torpedoed by this arms race lately — I use the imdb search to find the data on movies I’ve ripped from blu rays that I’ve bought. And I use the Goodreads search when I’m entering (manually) e-books that I’ve bought into the Emacs package for that. (Physical books have ISBNs printed in bar code form, so I can use various APIs for that and don’t need to resort to anything as tawdry as web scraping.)

These are just minor convenience things I’ve gotten used to over the years, so I could give them up… or I could go raging, raging against the dying of the open web.

Guess what I chose!

The result is on Microsoft Github.

The idea is:

1. First try to fetch the URL using the normal, fast method.
2. If this fails, use Selenium headless. This involves spinning up a web browser and then dumping the resulting DOM.
3. If this fails, spin up Selenium and a web browser window. This will allow the user to click around a bit, answering any challenges.

In 2) and 3), fetch-dom will save and reuse cookies, so that
hopefully 3) doesn’t happen as much, and 1) and 2) will be successful
more often.

So this requires a Python/Selenium installation that works, and
Chromium installed.

fetch-dom is synchronous by default, but is asynchronous if you give it the :callback keyword parameter.

This seems to work for my use cases — things usually work automatically, but once in a while it pops up a browser window, and I click a bit, and then things work headlessly for a while again.

*sigh*

These are the days of your life…

I was asked recently, "Do you use Org Mode protocol ... for browser to Emacs interaction? If so, were there any complications to set it up on Windows? Is there like bookmarklets for capturing or doing things?"¹

At the time I wasn't doing anything too fancy to incorporate Web Content into Org. I'd copy the URL from Vivaldi's address bar to the clipboard and (if applicable) the Web Content I'm interested in.² Then in Org, I'd yank the Web Content (if applicable), mark it and then do org-insert-link (C-c C-l) to turn it into a hyperlink. The marked text becomes what you see in the document. But I usually just specify the link Description simply as "LINK." In fact I created a macro (bound to the Insert key) to do this.

But I've started to use eww as my web browser for this. If I write something that I need to verify, I'll mark it and invoke eww-search-words (M-s M-w), which brings me to a DuckDuckGo page of search results. If I follow a search result that I like, I'll mark a small section and invoke org-store-link (C-c l) and create the link with org-insert-link, with the marked content as the Description. Thus org-store-link captures both the location and the context in one magical swoop. Here's an animated GIF that illustrates the process. Note that the video shows me capturing and referring to part of Sacha Chua's website that shows some neat solutions to launching a web browser from Emacs.³

² I use a clipboard manager so that I can copy content to the clipboard multiple times without clobbering all but the most recent item.

If you follow writers at all, you’ll have noticed that many prefer to write their prose in long hand even if they began their writing career with a computer. Tess Gerretsen and Neal Stephenson are two examples that come to mind. Both are serious, established writers who have no need for performative resistance to computers. Indeed, they both use computers to produce the final manuscript. They say they write in longhand to slow things down or to avoid premature editing.

I understand their urge but could never work that way. Writing by hand is excruciatingly slow and even painful to me. I didn’t start writing a lot until I got a computer and could do it without so much effort and discomfort. A middle ground is what’s often called a “writerdeck”. The idea is that it’s a device that’s completely dedicated to writing and is as simple as possible.

Chris Maiorana wrote an article that argued a pad and pen is the ultimate writedeck. I reject that for the reasons I stated above. Maiorana recognizes that often a computer is a good idea and has an article that describes building his own writerdeck. He wanted something free or cheap so he used a Raspberry Pi 4 that he had lying around, put Linux and Emacs on it, and restricted it to text mode. Later he added a few utilities such as Git but it remains a text only machine dedicated to writing with Emacs. Maiorana considers it the “maximum digital minimalism” but I’m more inclined to think of it as a minimal acceptable writing environment.

I don’t do social media other than Irreal, if you consider that social media, so I have no difficulty concentrating on my writing while using my everyday laptop. Not everybody is like that, of course, so if you find it’s hard to resist doom scrolling while you’re supposed to be writing, you may want to take a look at Maiorana’s post on his writerdeck.

"...how can people keep up with what you're learning?"¹

I've always kept a low profile on the Internet.  It can be a scary place!  But I've been asked to show glimpses of my online work to the people I was meeting in real life.

I agreed to chat with Sacha Chua about Emacs and Life (but not the Universe -- that'll be next time).  Emacs is worth revealing oneself for.  If people really do want to keep up with what I'm learning, they can visit here.

My init file² shows only a small aspect of how I have Emacs configured.  You'll want to see an example of my org file(s), my diary file, and the Lisp I have tucked away under my home directory.

Aside from Emacs, my workflow relies on Vivaldi and LibreOffice, so I'll try to show what I'm doing with them, as well.  Perhaps I can provide screen recordings, too!

"Sometimes it just takes somebody saying, your stuff is interesting. I'm telling you, your stuff is interesting."³

Thank you, again, Sacha!

Regular readers know I have a soft spot for AsciiDoc – I’ve written about it more than once, and it’s the markup behind the documentation of most of my bigger OSS projects (CIDER, nREPL, Projectile, RuboCop). It hits a sweet spot Markdown never quite reaches: rich enough for proper technical writing (admonitions, includes, real tables, cross-references), without dragging in the full ceremony of something like DocBook.

There was just one problem, and it nagged at me for years: editing AsciiDoc in Emacs was never much fun.

Background

For years the only real option was adoc-mode, and it was showing its age. The font-locking was uneven, it predated modern Asciidoctor syntax, and it lagged far behind what markdown-mode (and org-mode) offered. So I’d catch myself reaching for Markdown in situations where AsciiDoc was clearly the better tool – not because Markdown was better, but because markdown-mode was. That always bugged me.

Eventually the itch got bad enough that I did something about it. Back in 2023 I took over maintenance of adoc-mode, which had been dormant for years, and set myself a clear goal: get it to feature parity with markdown-mode. More recently I also started a brand-new asciidoc-mode built on top of tree-sitter. The target for both is the same – AsciiDoc support in Emacs that’s on par with Markdown, and ideally not far off from Org.

Less is more, unless it’s modes

Why two modes? They scratch slightly different itches:

• adoc-mode is the classic, regexp-based mode. It works on any reasonably modern Emacs, has no external dependencies, and now ships a pile of interactive features (markup commands, list editing, image preview, tempo templates).
• asciidoc-mode is the newer, tree-sitter-based mode. It leans on a real grammar for robust, accurate highlighting and good performance in large documents. It’s leaner by design, and it needs Emacs 30.1+ with tree-sitter.¹

If you want the kitchen sink on any Emacs, reach for adoc-mode. If you’re on a recent Emacs and want highlighting backed by an actual parser, try asciidoc-mode. Pick whichever fits your setup – both are actively maintained.

Recent developments

I’ve spent a good chunk of the past month bringing both modes to a place I’m genuinely happy with, and they’re now mostly feature-complete as far as I’m concerned. Some highlights:

• Modern AsciiDoc, not legacy AsciiDoc.py. Both modes now track the modern Asciidoctor spec – something I’d wanted to do for a while. +text+ and ++text++ are treated as passthroughs rather than monospace, curved-quote syntax ("`text`") is recognized, the block ID shorthand [#id] is supported, checklists are highlighted, and the menus and templates dropped a bunch of deprecated AsciiDoc.py leftovers.
• More uniform font-locking. I went through the faces in both modes and aligned them with markdown-mode and org-mode: bold renders as plain bold, emphasis as plain italic, structural markup (delimiters, list markers) fades into the background, and dedicated semantic faces cover metadata, URLs, footnotes, highlights, and roles. Switching between Markdown and AsciiDoc no longer feels jarring.
• Navigation that actually works. Clickable cross-references and links, an xref backend over anchors, context-aware completion, and – for adoc-mode – cross-file Antora cross-reference resolution.
• Tooling integration. Asciidoctor-backed preview/export and a Flymake checker that reports parser errors inline.
• Native code-block fontification. [source,LANG] blocks in asciidoc-mode are highlighted using the language’s own major mode, just like in markdown-mode and org-mode. adoc-mode had added support for this a while back.

Getting asciidoc-mode where I wanted it also meant sending a few fixes upstream to the tree-sitter-asciidoc grammar it builds on. A grammar-backed mode is only as good as its grammar, so some of the work happened a layer below Emacs. If you’re curious about that side of things, I wrote up the broader experience in building Emacs major modes with Tree-sitter.

Give it a try

If you’ve been avoiding AsciiDoc in Emacs because the tooling wasn’t there – I get it, that was me too. But the situation is genuinely different now. Grab adoc-mode or asciidoc-mode, point it at one of your .adoc files, and see how it feels.

And please share your feedback. Both projects are at the stage where real-world usage surfaces the rough edges I can’t see myself. Bug reports, ideas, and PRs are all very welcome on the respective issue trackers.

Together we can make AsciiDoc a first-class citizen of the Emacs ecosystem!²

That’s all from me, folks! Keep hacking!

It's been a little while since my last agent-shell update, so let's go through the latest highlights as of v0.55.

What's agent-shell?

agent-shell is a native Emacs mode to interact with AI agents powered by ACP (Agent Client Protocol).

Picking up where I left off

If you noticed slower project activity in April, this is why. I'm getting better at the new 24-hour job, so I've resumed working on agent-shell.

I'm still chipping away at the backlog that built up while I was away, but if there's anything in particular you'd like me to look at, feel free to ping.

Anthropic, Google, and why ACP matters

With Anthropic's SDK subscription support changing, Google's Gemini CLI deprecation, and Antigravity's unclear support for the Agent Client Protocol (ACP), vendor-neutral tools matter more than ever.

Luckily, agent-shell is built on ACP, which sidesteps the problem. When a vendor changes course, you can swap providers and keep using your preferred tool. No need to reshape that hard-earned muscle memory.

On that note, the list of agents supported by agent-shell continues to grow.

Supported agents

Here's a list of the latest agents now supported by agent-shell.

• Auggie
• Claude
• Cline
• CodeBuddy (new by @illidan127)
• Codex
• Cursor
• Factory Droid
• Gemini CLI
• GitHub Copilot CLI
• Goose
• Hermes (new by @yitang)
• Kimi Code (new by @nicolaisingh)
• Kiro
• Mistral Vibe
• OpenCode
• Pi
• Qwen Code

agent-shell needs your support

Speaking of vendor-neutral tools being more important than ever, there are a couple of ways to help keep agent-shell going. Some cost money, others just a click. All are appreciated ;)

Sponsorships for agent-shell longevity

agent-shell has been attracting quite a few users. It's nice to hear folks are using agent-shell on a daily basis. They are often relieved agent-shell exists as an alternative to AI-tools commonly mandated at work. Those tools have well-funded engineering teams behind them, while agent-shell is just me, an indie dev ;) Time spent on agent-shell is time away from work that pays the bills, so if it's useful to you, please consider sponsoring the project.

Every individual sponsorship genuinely helps keep the project going. And if your employer benefits from your agent-shell use, they're typically in a position to contribute at a scale individuals can't, so nudge them to chip in too.

Hey, I'm looking at you, folks at Google, GitHub, GitLab, NVIDIA, Oracle, Red Hat, Yelp, Venmo, ARM, Spotify, Augment Code, Hinge, Mercury, Nubank, Veeva… Some of you are using agent-shell. Nudge your employer ;)

GitHub stars for Anthropic credit

Anthropic offers 6 months of free Claude Max 20x for qualifying open-source projects with at least 5,000+ GitHub stars. Starring agent-shell costs nothing and can save me some money. We're only a 5th of the way there ;) so if you don't mind a couple of clicks, the project can really use another GitHub star.

Speaking of GitHub stars, agent-shell is now my most popular Emacs package, recently overtaking chatgpt-shell.

New markdown renderer

agent-shell now ships with a brand new, more performant inline markdown renderer. This is the biggest internal change in some time. Enabled by default via agent-shell-markdown-render-function (moving away from the overlay-based renderer in shell-maker).

Access/navigate table content

Table content is now accessible. Point can land on any cell, which wasn't possible with the previous overlay implementation. In addition, tables are now also navigable: TAB and S-TAB move between cells.

Improved source block support (enabled by default)

Source-block syntax highlighting is now on by default. The per-snippet copy button is now keyboard-accessible too (previously mouse-click only, due to the overlay implementation).

New blockquotes support

Blockquotes now render in both shell and viewport. More importantly, you can select text in either a viewport page (or the shell itself), press r (for reply) and the selection becomes a blockquote in a fresh prompt.

Viewport

Shell

Session restoration

Session restoration got a meaningful overhaul (#605 by @nhojb), now exposed via agent-shell-session-restore-verbosity, with four levels:

• minimal (default): title only, so restore is fast and quiet (needs session/resume support).
• last: render the last prompt turn (needs session/load support).
• first-last: render the first and last prompt turns (needs session/load support).
• full: replay the whole conversation (needs session/load support).

Feature availability is agent-specific, requiring either session/resume or session/load request support. agent-shell degrades as needed, ultimately falling back to creating a new session.

Note that anything but minimal verbosity is fairly new, so please report bugs or rough edges.

Relatedly, agent-shell-session-strategy now defaults to 'prompt, and 'new-deferred has been retired.

Session forking

You can now fork the current session, starting a new shell that shares the conversation history so far and diverges from there. Invoke via M-x agent-shell-fork.

Restart/reload session

You can now restart the current shell anew (drop history) via M-x agent-shell-restart or reload (keep history) via agent-shell-reload.

Downloads/Temp shells

The new agent-shell-new-downloads-shell and agent-shell-new-temp-shell commands create agents anchored at either ~/Downloads or a temp directory. Both are also reachable via C-u M-x agent-shell.

TRAMP support

acp.el #20 by @martenlienen landed support for ACP connections over TRAMP, now making it possible to drive remote agents from agent-shell. Pair it with agent-shell-tramp for the user-facing integration.

Viewport improvements

Viewport interaction (setq agent-shell-prefer-viewport-interaction t) continues to be my primary way to interact with agents. It is focused (see only the latest interaction), fast (single-key bindings: y = yes, c = continue, m = more…), and offers a richer editing experience (dedicated prompt-crafting buffer).

The viewport is just a viewport to shell content. You can have your cake and eat it too, by jumping to the related shell buffer if needed.

Queueing

From a viewport, you can press r to reply to the latest agent response. In the past, you could only reply to idle agents. You can now press r to reply to busy agents too, automatically queuing requests on submission.

List editing mode

A new (basic) agent-shell-list-edit-mode lets you edit list-style content inside the viewport.

Improved buffer selection

Some commands prompt you to pick one of your active shell buffers (e.g. M-x agent-shell-send-region-to). The picker now shows extra context for each buffer to help you choose.

The same mechanism is now used by the new M-x agent-shell-switch-buffer command. More on the underlying API later.

Improved folding

Folding got smarter (#608 by @codeluggage):

• M-x agent-shell-ui-toggle-fragment toggles the fragment at or near point (DWIM).
• M-x agent-shell-ui-toggle-all-fragments cycles globally between all-expanded and all-collapsed.

Together they replace the previous agent-shell-ui-toggle-fragment-at-point, which is now an internal primitive.

c joins the viewport reply gang

You can now press c from a viewport to quickly send a "continue" request, joining the rest of the single-key reply shortcuts:

• c: replies "continue" (new)
• y: replies "yes"
• m: replies "more"
• a: replies "again"
• 1 … 9: replies with the corresponding numbered choice
• r: opens the reply compose buffer
• R: same as r, with the agent response quoted

More compact status rendering

Tool call status is now rendered as a compact icon-based label by default (agent-shell--inverse-icon-status-kind-label). agent-shell-styles.el ships several alternatives, picked via agent-shell-status-kind-label-function.

To get the previous word-based label back:

(setq agent-shell-status-kind-label-function
      #'agent-shell--inverse-label-status-kind-label)

Codex defaults

You can now set a default model and session mode for Codex via agent-shell-openai-default-model-id and agent-shell-openai-default-session-mode-id (#405 by @robjgray). Both must match an ID from Codex's "Available models" / "Available modes" listings.

Emacs 31 fixes

Headers had a few rendering hiccups on Emacs 31. These are now fixed (#588 and #590 by @nhojb, #463 by @ftlio). Warnings from deprecated when-let usage were also cleared.

Wayland clipboard support

wl-paste is now a supported clipboard handler for pasting images on Wayland (#461 by @martenlienen).

Windows clipboard support

Similarly, pasting clipboard images now works on Windows via PowerShell (#572 by @repelliuss).

Header improvements

The graphical header got minor tweaks here and there. For example, thought level is now displayed in the header. It can be changed via M-x agent-shell-viewport-set-session-thought-level as well as menus (#601 by @martenlienen).

Session config options

agent-shell now supports ACP session config options (#553 by @greggroth and #613 by @catern). Bind C-c C-s (or call agent-shell-set-session-config-option) to pick from the options the agent advertises. Broadcasted as config-option-update and available externally via agent-shell-subscribe-to.

Interrupt confirmation

You can now skip interrupt confirmations by unsetting agent-shell-confirm-interrupt (#424 by @emil-e).

Public functions

Resume sessions by ID

You can now resume an existing session by its ID via M-x agent-shell-resume-session (#332). Primarily useful for external integrations.

Outgoing request decorator

You can now use agent-shell-outgoing-request-decorator to tag or transform outgoing requests.

Subscribe to idle events

agent-shell-subscribe-to now broadcasts idle events (#509 by @arthurgleckler).

Getting shell buffers

agent-shell-shell-buffer returns the underlying shell buffer for the current context.

Last vs interaction at point

agent-shell-goto-last-interaction jumps to the latest prompt/response pair, while agent-shell-interaction-at-point returns the interaction at point as data.

Shell status

agent-shell-status returns 'busy, 'blocked, or 'ready status for any shell buffer.

Session title

The agent-supplied session title is now exposed via the session-title-changed event (delivered via agent-shell-subscribe-to) (#559 by @smagnuso). Can be handy for buffer names, bookmarks, or recent listings.

New third-party packages

The agent-shell family of third-party packages keeps growing. Recent additions:

• agent-shell-knockknock: Notifications for agent-shell via knockknock.el.
• agent-shell-notifications: Desktop notifications for agent-shell events.
• agent-shell-hud: Real-time agent-shell status overlay via a floating dashboard.
• agent-shell-pet: Codex-like pets that broadcast agent-shell session states.
• agent-shell-tramp: Tramp integration for agent-shell.
• agent-circus: Run AI coding agents in sandboxed Docker containers.

Pull requests

Thank you to all contributors for these improvements!

• #308: Fix heartbeat nil value crash in timer and busy indicator (@ElleNajt)
• #340: Add documentation about the OAuth Anthropic authentication (@chemtov)
• #397: Add detailed context usage indicator mode (@emil-e)
• #398: Expose outgoing-request-decorator as a defcustom (@emil-e)
• #405: Codex defaults for session mode and model (@robjgray)
• #408: Use diff-command for diffing (@timfel)
• #413: Track and manage diff buffers for each permission request (@emil-e)
• #418: Add defvar for agent-shell-mode-hook + test (@emil-e)
• #420: Replace all references to "Claude Code Agent" with "Claude Agent" (@jinnovation)
• #421: Add agent-shell-clear (@Makesesama)
• #424: Add agent-shell-confirm-interrupt option (@emil-e)
• #425: README: Update all references to Claude Code (@jinnovation)
• #429: Viewport attachment fixes (@nhojb)
• #438: Fix for structured input from toolCall.rawInput.plan (@timfel)
• #442: Add related project agent-circus to README.org (@rpoisel)
• #445: Use project-name instead of default-directory in header (@bcc32)
• #446: Droid: use native acp client and support default model and mode (@kohnish)
• #450: Fix restart using wrong default-directory (@zackattackz)
• #453: Ensure that viewport compiles (@martenlienen)
• #457: Prefer cache directory over tmp for caching (@martenlienen)
• #460: Unhandled method returns an error, unblocking client (@0x6362)
• #461: Add wl-paste as a Wayland image handler (@martenlienen)
• #463: Fix header text invisible when font-get :size returns 0 (@ftlio)
• #469: Do not create a file if no image in Wayland clipboard (@martenlienen)
• #473: Caching project files completions for improved performance (@Gleek)
• #477: Handle non-text content in user_message_chunk during session load (@Gleek)
• #483: Add CodeBuddy agent support (@illidan127)
• #489: Snapshot session strategy in any case (@timfel)
• #492: Update claude-agent-acp repository (@Gleek)
• #498: Normalize missing MCP transport collection fields for ACP compatibility (@CsBigDataHub)
• #503: Add agent-shell-macext to related projects (@cxa)
• #509: Add agent-shell-idle-alert-functions (@arthurgleckler)
• #513: Quote reply to the complete response with R (@martenlienen)
• #515: Make detection of binary files more robust (@martenlienen)
• #523: Add agent-shell-org-transcript to Related projects (@lllShamanlll)
• #528: Add support for Kimi Code CLI using ACP (@nicolaisingh)
• #529: Sort the session list based on recency (@smagnuso)
• #530: Add simple blinking circle as busy indicator (@rudolf-adamkovic)
• #532: Fix removing queued messages (@Gleek)
• #536: Add programmatic query API: agent-shell-query and agent-shell-shell-buffer (@eddof13)
• #539: Add ob-agent-shell to related projects in readme (@eddof13)
• #545: Keep buffer name on agent-shell-reload and -restart (@timfel)
• #550: Add agent-recall to related projects (@Marx-A00)
• #551: Avoid gitignore update for external data dirs (@Silex)
• #552: Use helper function from shell-maker rather than eob (@smagnuso)
• #553: Add ACP session config options support (@greggroth)
• #554: Fix error when cancelling session selection prompt (@Gleek)
• #555: Add some niceties useful for agent-shell-list (@vermiculus)
• #559: Expose topic in agent-shell (@smagnuso)
• #561: Update Pi coding agent logo to look more official (@jeff-phil)
• #565: Enable @ and / completion when reading queued prompts (@Gleek)
• #571: Fix unkillable buffer after major-mode change (@Scott-Guest)
• #572: Add clipboard image support for Windows (@repelliuss)
• #574: Add agent-shell-pet link to README (@lgmoneda)
• #582: Add a few additional forward declarations (@tychoish)
• #583: Add Hermes Agent support (@yitang)
• #588: Fix header foreground color (emacs 31) (@nhojb)
• #589: Only trim response region when region is active (@martenlienen)
• #590: Fix context-limit header color (emacs-31) (@nhojb)
• #595: Fix / completion regression in viewport buffers (@Gleek)
• #600: Do not emit permission-request for auto-handled permissions (@Gleek)
• #601: Expose thought level (reasoning effort) in header, mode line and keymaps (@martenlienen)
• #602: Update README with Opencode and Ollama setup instructions (@dvictori)
• #605: Add agent-shell-restore-context defcustom (@nhojb)
• #608: Toggle folding for everything & comfortably fold at point (@codeluggage)
• #609: Prevent accidental auto-scrolling in viewport buffers on tool calls (@martenlienen)
• #611: Fix agent-shell-hermes-acp-command (@TamsynUlthara)
• #613: Improve completion for set-session-config-option (@catern)
• #618: Fix header not showing session mode name (@deftsp)
• #621: Reindent Elisp files (@bcc32)
• #623: Add agent-shell-hud to related packages (@nohzafk)
• #625: Fix source-block face background not rendering when theme loads after package (@phairoh)
• #627: Hermes: add default-session-mode-id to match other agents (@yitang)
• #629: Write .agent-shell/ to .git/info/exclude instead of .gitignore (@phairoh)
• #632: Render tool call parameters for non-standard tools like MCP calls (@martenlienen)
• #633: Add GitHub Actions workflow for ERT tests (@phairoh)
• #634: Update art generated by agent-shell-hermes--ascii-art (@TamsynUlthara)
• #639: Preserve window position when restarting (@Gleek)

Bug fixes

• #202: Header icon is double the expected size
• #278: Heartbeat causes high CPU usage with many agent buffers
• #366: .agent-shell/ directory at risk when switching git branches
• #400: agent-shell-viewport-reply-1 errors with "Text is read-only"
• #401: Garbled characters output when using non-English languages
• #412: Diff buffer management is messy
• #414: agent-shell-mode-hook timing makes subscribing to events difficult
• #417: Unhandled notifications with kiro
• #426: Starting conversation before agent has initialized leaves "dangling" text
• #431: Heartbeat timer keeps running after failed/abandoned authentication in OpenAI
• #435: xclip clipboard handler silently saves text as PNG in terminal mode
• #441: Background agent notifications treated as stale after session/prompt response
• #443: image-type: Invalid image type 'svg on calling agent-shell
• #455: agent-shell enters frozen/hanging state when receiving unknown notifications
• #462: Header text invisible when font-get :size returns 0
• #465: Session load crashes on non-text user message chunks (e.g. images)
• #466: agent-shell-diff-accept-all / -reject-all now focus the originating shell
• #468: wl-paste-image-handler breaks pasting text
• #481: History input rolls back in insert editing mode while pressing up/down arrows
• #485: Shells created in other workspaces no longer display
• #493: Tables rendered in agent-shell break cursor (point) navigation
• #533: Can't install agent-shell from MELPA
• #548: Copied highlighted text from agent output includes trailing backtick
• #563: "Cannot modify map in-place" when starting agents
• #577: agent-shell-get-config does not work in an agent-shell-command-prefix function
• #587: Long region preview's "Expand…" button is sent literally to the agent
• #617: OpenCode: consent prompt shows empty input when request_permission arrives before tool_call_update populates rawInput

Lots of polish

Beyond what's showcased, I've poured much love and effort into polishing the agent-shell experience. Interested in the nitty-gritty? Have a look through my regular commits.

Make the work sustainable

If agent-shell is useful to you, please consider sponsoring the project. I'm now back to working on agent-shell daily.

LLM tokens aren't free, and neither is the time dedicated to building this stuff (especially as an indie dev). I also have bills to pay ;)

Unless I can make this work sustainable, I will have to shift my focus to work on something else that is.

✨ Sponsor agent-shell ✨

Ian Pan has curated a nice collection of Emacs caught in the wild. By “in the wild” I mean “in popular culture”: things like movies and comics. Most of us have seen the familiar scene from Tron but Pan has a bunch of others.

One example is the famous scene from Silicon Valley in which Richie and Winnie start arguing about Tabs versus Spaces and end up discovering that one is a Vim user and the other an Emacs user. I’ve seen that scene many times but didn’t realize where it came from so I learned something new from his post.

The other surprising thing—to me—is that Emacs also makes appearances in comics. What’s interesting is that you rarely see any editor other than Emacs or Vi(m) mentioned outside geek circles. Perhaps the current cohort of hackers will change that and we’ll start seeing references to VS Code. Or maybe not. VS Code does have a lot of users but I haven’t seen the same culture grow up around it. We’ll see.

I recently wrote a post about writerdecks and minimalist “distraction-free” writing environments in general. I concluded that the most minimalist writing environment you could get is a cheap notebook and Bic pen you could get at any supermarket.

However, as a digital minimalist, and one who writes at a high enough volume, a writerdeck starts to make a lot of sense. So I thought I’d try to make one.

But, I wanted it to be a “low buy” or “no buy” situation. Luckily, I had a Raspberry Pi 4 lying around unused, so I snapped it up. I installed a lightweight, minimalist distribution of Debian called DietPi and installed Emacs with no GUI. (Of course, I also installed git and a lot of other stuff by now, but I am keeping it GUI-free.)

We’re talking MAXIMUM digital minimalism here.

I am using tmux as a sort of window manager, spawning sessions and windows and switching between them as needed. I’ve also opted to run Emacs as a daemon and connect to it with emacsclient, so no matter what session or window I’m in, I’m attached to the same running Emacs state. This means I can view any and all available buffers and have Claude edit Emacs lisp files and see live results without having to reload Emacs.

For aesthetic reasons, I’ve opted for an “amber CRT” color scheme with the available 16-color palette in the text interface. This makes my workstation feel like a DOS-era word processor.

I love this so much it’s hard to contain my excitement.

I plan on making a more in-depth video on this topic later to actually demonstrate the system live and show some of the config-mongering I went through to get it just right.

I’ve really enjoyed the results as I’ve grown accustomed to a purely text-based (no mouse!) workflow. The only downside is that it reverses the classic Emacs paradigm of having Emacs colonize my desktop. Instead, Emacs is a guest in tmux. C’est la vie.

Thanks for reading, be sure to check out my books about similar topics: Emacs For Writers and Git For Writers.

The post When tmux is your window manager appeared first on Chris Maiorana.

When I released blogmore.el v4.7.0 yesterday I finished off by saying that it was my intention, at some point, to rework the frontmatter-handling code so that it did proper YAML parsing. As often happens with these sorts of things, "some point" ended up being that evening.

I've rewritten everything to do with handling properties in the frontmatter so that it now uses yaml.el. This has a number of knock-on effects. The first and most obvious effect is that anything that is a list/array in the frontmatter is actually properly treated as a list. A good example here is tags. Now you can have your tags look like:

tags: [BlogMore, Emacs, "Emacs Lisp", Lisp, "blogmore.el", coding]

or:

tags:
  - BlogMore
  - Emacs
  - Emacs Lisp
  - Lisp
  - blogmore.el
  - coding

and blogmore.el will still handle things fine. The same holds for series too.

It should be noted, however, that because I'm now using actual YAML serialisation code, most other forms of a list will all end up being transformed into this kind:

tags: [BlogMore, Emacs, "Emacs Lisp", Lisp, "blogmore.el", coding]

So if you have a bare list:

tags: BlogMore, Emacs, "Emacs Lisp", Lisp, "blogmore.el", coding

and you make an edit to the tags via blogmore.el, it will end up as the version enclosed in []. BlogMore itself supports all three versions so this works fine.

There is a breaking change here too, which in part explains the reason I bumped the version to 5.0.0: because series can now be treated as a list I've removed the blogmore-set-series command and instead replaced it with blogmore-add-series and blogmore-remove-series. Both can of course be found in the transient menu.

Another big change in this release is the way that existing values are loaded up from your blog. Previously, when you went to add a category, tag or series, blogmore.el would use ripgrep (or a combination of find and grep if rg wasn't available) to pull out values to help populate a completion list. This worked fine as long as a) the frontmatter property was all on one line and b) the body of a post didn't contain something that looked like a frontmatter property. With this release of blogmore.el I've dropped this approach in favour of calling blogmore itself and using the dump command to get the actual lists of categories, tags and series.

This does mean that BlogMore needs to be installed in a location where blogmore.el can see it, and to help with this I've added a new defcustom called blogmore-command. By default this is set to call whatever version of blogmore can be found in your exec-path; if this results in unexpected behaviour you can set blogmore-command to point to a specific copy of blogmore.

There is, however, a small downside to this beneficial¹ approach: calling on blogmore and parsing all posts to get the values is generally going to be slower. With this in mind I've built in a cache for these values. The first time you load up the categories, tags or series, the values are held on to so that subsequent prompts are instantaneous (meaning there is no further call to blogmore). To ensure this doesn't confuse things, when you switch blog (blogmore-work-on) the caches are cleared. In the unlikely event that there is a problem with this approach, I've also added a blogmore-clear-caches command to force the clearing of the caches.

There are some other small QoL changes under the hood and also to the interface. I've moved some things around in the transient menu, and also ensured that a couple of options are better-disabled depending on the context.

All of this makes the package even more robust. Something that started as a quick hack back in March has turned into a tool I heavily lean on. Hopefully, for anyone who might happen to use BlogMore and GNU Emacs, it'll be a useful daily-driver for them too.

My ongoing journey with vc-dir and vc-mode led me into wanting to delete a stash (not to pop). There are "z" keybindings in vc-dir:

z c	vc-git-stash
z p	vc-git-stash-pop
z s	vc-git-stash-snapshot

but what about delete?, and are there any others?

In vc-dir you get a rather nice little Stash section tacked on at the bottom listing all your stashes:

I genuinely assumed I was missing something obvious, so I did the sensible Emacs thing and hit C-h m to describe the mode, scrolled through the whole keymap, and, nothing about stashes at all.

Well how about C-h b (describe-bindings)?, initially nothing!, however I stumbled on a solution, if the point is on a stash name, the following is exposed!

C-k	vc-git-stash-delete-at-point
RET	vc-git-stash-show-at-point
=	vc-git-stash-show-at-point
A	vc-git-stash-apply-at-point
C	vc-git-stash
P	vc-git-stash-pop-at-point
S	vc-git-stash-snapshot

Surprisingly difficult to find.

and C-k does obviously seem a natural fit to delete a stash, but what wasn't obvious was the fact that the point had to be on the stash name.

I couldn't quite understand why these keybindings were so difficult to find, so I went digging into vc-git.el and there it was, the bindings are not part of vc-dir-mode-map at all, they live in their own little keymap:

(defvar-keymap vc-git-stash-map
  :parent vc-git-stash-shared-map
  "<down-mouse-3>" #'vc-git-stash-menu
  "C-k"            #'vc-git-stash-delete-at-point
  "="              #'vc-git-stash-show-at-point
  "RET"            #'vc-git-stash-show-at-point
  "A"              #'vc-git-stash-apply-at-point
  "P"              #'vc-git-stash-pop-at-point)

And the crucial detail, this keymap is not installed as the major mode map, it is slapped directly onto the stash lines as a keymap text property when those lines are rendered. So the bindings are only live when point is literally sitting on a stash, which is rather elegant actually, but it does mean describe-mode never sees them, because C-h m only reports the major mode's own keymap, and a text-property keymap is invisible to it. That explained my confusion completely, I was not going mad after all!

And the Emacs manual, well I did have a little look but found nothing. It seems these keybindings are almost impossible to find, but now I have found them this blog post should help me to remember.

So, lesson learned, and a genuinely useful one I think, C-h m is not the whole story. When a mode renders interactive regions, buttons, clickable lines, embedded widgets, those often carry their own text-property keymaps that describe-mode will never show you, and the move in those situations is C-h k or C-h b with point actually on the thing.

Anyway, C-k on a stash line to drop it, that is the headline, write it on a sticky note, you will want it eventually!, if you are a vc-mode user of course, I suspect that magit has this very discoverable already through the stash menu.

Sometimes you just gotta laugh at yourself.

Interview with an Emacs Enthusiast in 2023 with Emerald McS., PhD

People don’t quit Emacs. They just die at some point.

Brilliant.

Quick announcement: this blog now lives on the small net too. If you have a Gemini client around, point it at:

gemini://gemini.rahuljuliato.com

You'll find the same posts there, rendered as plain gemtext.

Wait, Gemini?

Gemini (the protocol, in case the name now reminds you of other things) is a small internet protocol that sits somewhere between Gopher and the early web. It works like this: the client sends a single request, receives a single response, and the connection is done, always over TLS. Pages are written in a tiny markup format called gemtext, which gives you headings, links, lists, preformatted blocks, and that's about it. A link is always its own line, so pages end up reading like a well-organized text file.

The whole spec is short enough to read in an afternoon, and people have written servers and clients for it in pretty much every language you can think of. The community around it is usually called the "small net" or "smolnet": personal capsules (that's what sites are called over there), gemlogs, and a general feeling of the web before it became an application platform.

I've been lurking in Geminispace for a while and finally decided this blog should have a capsule of its own. The mirror is generated from the same Markdown sources as the web version, so both stay in sync.

Browsing it from Emacs

This site has always been totally browsable on EWW, I wanted that by design, the web version degrades gracefully to plain HTML and reads just fine in a text buffer. But EWW speaks HTTP only. For Gemini (and Gopher, and Finger), the package you want is elpher. It's available on NonGNU ELPA, so a plain M-x package-install RET elpher RET gets you there. Then:

M-x elpher-go RET gemini://gemini.rahuljuliato.com RET

It renders gemtext beautifully in a buffer, history and bookmarks included, and it integrates gracefully with EWW: bump into an http:// link inside elpher and it opens in EWW, follow a gemini:// link from EWW and elpher picks it up. EWW for the big web, elpher for the small one, and you never leave Emacs.

Other clients

The official project site keeps a list of clients for every taste, from TUI ones like amfora to full GUI browsers like Lagrange:

geminiprotocol.net/software

Pick one, type in the address above, and enjoy the quiet side of the internet. See you there!

DC Toedt is a lawyer and professor of practice who uses Emacs and Org Mode. He wanted a small Emacs Lisp function to convert Org Mode syntax to Markdown and copy it to the clipboard to make it easier to copy the materials he's writing for a course on contract drafting. This seems to be a common need, and here are several other approaches:

• embark-org-copy-as-markdown in embark
• Marcin Borkowski: 2021-05-02 Org-mode to Markdown via the clipboard
• Marcel Kapfer - Copy an Org Mode region as Markdown
• Reddit
• Reddit

Anyway, DC shared how he used Claude to generate a simple function to do it, which is here under public domain:

(defun my/org-to-markdown-clipboard ()
  "Export org region (or buffer) to Markdown and copy to clipboard.
With no active region, exports the whole buffer."
  (interactive)
  (require 'ox-md)
  (let* ((text (if (use-region-p)
                   (buffer-substring-no-properties (region-beginning)
(region-end))
                 (buffer-substring-no-properties (point-min) (point-max))))
         (md (org-export-string-as text 'md t '(:with-toc nil
                                                :with-author nil
                                                :with-date nil
                                                :with-title nil))))
    (kill-new md)
    (message "Markdown copied (%d chars)" (length md))))
(with-eval-after-load 'org
  (define-key org-mode-map (kbd "C-c m") #'my/org-to-markdown-clipboard))

You can e-mail me at sacha@sachachua.com.

A quick update to blogmore.el. Having recently added series support to BlogMore it made sense that I then add a quick way of adding a post to a series in the package.

You can, of course, set a new one too, but the idea here (as with categories and tags) is that you can quickly find back an existing series and add the current post to it.

Also, as with tags, the expectation is that either a single series is being used, or if more than one series is in play for a post they'll be listed as a comma-separated list. The issue here is that while BlogMore supports this:

series:
  - Some series of posts
  - Some other series of posts
  - Yet another series of posts

the frontmatter-handling code in blogmore.el isn't very sophisticated at all; it doesn't actually handle it as actual YAML, instead just treating it as a set of key/value pairs separated by a colon.

At some point soon I want to give blogmore.el a revamp and base all of the frontmatter-handling code on something like yaml.el. I did do some experimenting last night to drop it in and handle proper lists. It worked well enough, but I abandoned the work as I realised I really wanted to start again from scratch and build blogmore.el from the bottom up using that package.

Some time soon...

I chatted with Prot about the Emacs Carnival June 2026 topic Underappreciated Emacs Built-ins. Thanks to Ross A. Baker for hosting the carnival!

Working on the transcript…

Related links:

• Top (GNU Emacs Manual)
• YE24: Sacha and Prot Talk Emacs - Newbies/Starter Kits

You can e-mail me at sacha@sachachua.com.

Raw link: https://www.youtube.com/watch?v=yuJYEua0ZwA

I will join Sacha’s live stream this Thursday to talk about underappreciated features that are built into Emacs. There are a lot of nice things that are available out-of-the-box (plus many packages that build on top of them). I am looking forward to it!

The video will be recorded for future reference.

It's Emacs Built-ins appreciation month! I'm coming to appreciate the menu bar more. What built-ins do you appreciate? Write about it and send Ross a link!

• Emacs updates:
  • Emacs 31.0.90 pretest is available (Reddit, Linux Compatible, Irreal)
• Upcoming events (iCal file, Org):
  • Emacs Berlin: In-Person-Only Emacs-Berlin Stammtisch https://emacs-berlin.org/ Tue Jun 9 1900 Europe/Berlin
  • OrgMeetup (virtual) https://orgmode.org/worg/orgmeetup.html Wed Jun 10 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Thu Jun 11 0000 Asia/Singapore
  • Atelier Emacs Montpellier (in person) https://lebib.org/date/atelier-emacs Fri Jun 12 1800 Europe/Paris
  • M-x Research: TBA https://m-x-research.github.io/ Wed Jun 17 0800 America/Vancouver - 1000 America/Chicago - 1100 America/Toronto - 1500 Etc/GMT - 1700 Europe/Berlin - 2030 Asia/Kolkata - 2300 Asia/Singapore
• Beginner:
  • How to Install Emacs on a Chromebook in 2026 (07:15)
  • How to Setup Emacs on a Chromebook Without Elisp in 2026 (10:37)
• Emacs configuration:
  • Useful Emacs key bindings (@spnw@plexwave.org)
  • function to list bindings
  • Raymond Zeitler: Emacs and the Numeric Keypad
  • new embark-automatic-prefix-help-mode (@oantolin@mathstodon.xyz)
  • How I structure my Emacs init.el file (27:05, GitHub)
  • minimal-emacs.d: A Customizable init.el and early-init.el for Optimized Startup and Better Emacs Defaults [Release 1.5.0]​ (Reddit)
  • dotfiles/OpenBSD/.emacs.d at main · scovl/dotfiles · GitHub (@lobocode@hachyderm.io)
• Emacs Lisp:
  • k3jph/stops-el: stops: Guards in Emacs Lisp · GitHub (@k3jph)
  • imarko/vared.el: Emacs command for interactively editing a variable - Codeberg.org (@zrzz@fosstodon.org)
• Appearance:
  • vim-tab-bar: A Vim inspired Emacs tab-bar that adapts to any Emacs theme [Release 1.1.5]​ (Reddit)
  • svg-line: Better Status Bars for Emacs (Reddit, lobste.rs)
  • Raymond Zeitler: Change Emacs Cursor to Indicate Overwrite Mode
  • tykayn/emacs-theming (@tykayn@mastodon.cipherbliss.com)
  • Emacs themes inspired by pixel art palettes (Reddit)
  • How to Change Themes in Emacs (01:31)
  • How to Inhibit the Welcome Screen in Emacs (01:12)
  • How to Maximize Emacs' Screen Upon Startup (01:24)
  • How to Hide the Tool Bar, Scroll Bar, and Menu Bar in Emacs (02:00)
  • Nicolas Rougier's Talk at 39C3 - The art of text (rendering) (Reddit) see discussion for more thoughts on SVG in Emacs
• Navigation:
  • Post a solution: embark-act-on-last-message
  • Project-x revived with Emacs 30+ support! (Reddit) - session persistence
  • Little LLM helper function for copying file:line coordinates
  • kirigami: A unified Emacs method to fold and unfold text in Emacs: outline, outline-indent, org-mode, markdown-mode, vdiff, hideshow, treesit-fold… [Release 1.1.2]​ (Reddit)
• Writing:
  • mmarshall540/electric-sentence: Automatically add the extra space between sentences in Emacs. · GitHub (Reddit)
  • quick-sdcv: Emacs offline dictionary using 'sdcv' [Release 1.0.5]​ (Reddit, Irreal)
  • Notes, Linking and Tagging systems in Emacs
  • blk: creating and navigating titles of text files, linking between them
  • Dave Pearson: blogmore.el v4.6.0 - show toc, show toc inline
• Org Mode:
  • Much Ado About Emacs 014: Org-Mode and the Capture System, creating headings at different levels, and changing bindings
  • TAONAW - Emacs and Org Mode: Correcting photo orientation for org-mode in Linux (Irreal)
  • Citing with Citum in Emacs org-mode | News | Citum (@bdarcus@mas.to)
  • How I wrote an Emacs plugin to build my blog (@evgandr@bsd.cafe)
  • Migrating a Zola blog from Markdown to Org-mode — with a lint/export/check pipeline to keep them in sync | The Cloudlet
  • Org development: Generate images in TOC for HTML export
• Completion:
  • Beyond ICR: Incremental 'Suggesting' Read in Emacs (YouTube 20:10, Reddit, @chiply@fosstodon.org)
• Coding:
  • Introducing magit-difftastic: integrate difftastic into magit (Reddit)
  • inline-review: review merge/pull requests directly within emacs (Reddit)
  • Building alc-jj-log-view-mode — Alex Carney (@alcarney)
  • Building IOS Apps With Doom Emacs | Wassim Mansouri (HN)
  • CEDET for Plan 9 coding (01:14)
  • Tim Heaney: Ziglings
• Shells:
  • A Simple jj Integration for eshell — Alex Carney (@alcarney)
  • Raymond Zeitler: exeln: EXEcute LiNe
    • Follow-on to exeln
• Web:
  • Irreal: My Growing Appreciation For EWW
• Mail, news, and chat:
  • Setting up offline email for Microsoft O365 with notmuch and emacs | Ashish Panigrahi (@paniash@ioc.exchange)
  • Lars Ingebrigtsen: Super Simple Spam Splitting for Gnus
  • New Elfeed 4.0.0 release (Irreal, HN)
  • Chatting via Meshtastic in Emacs | Andros Fenollosa
• Multimedia:
  • Marcin Borkowski: Copying images in Emacs
  • Kokoro-onnx with Cuda for text to speech with Emacs (01:26:56)
• Fun:
  • I ported GNU Emacs 30.2 to the browser with WebAssembly (Reddit)
  • Emacs Appearance in Pop Culture (Reddit)
• AI:
  • Structural diffing in Emacs; deterministic agent harnesses (GitHub)
  • Emacs client for Pi Coding Agent (Reddit)
  • jaketothepast/codetutor: An AI Pair Programmer, that teaches you to code as you write, for Emacs · GitHub (HN)
• Community:
  • Fortnightly Tips, Tricks, and Questions — 2026-06-02 / week 22
  • Learning Emacs with Progressive Vision Loss
  • Amin Bandali: Free software activities in May 2026
  • Emacs Chat 25: Ben Zanin (@gnomon@mastodon.social) (YouTube 59:30)
  • Sacha Chua: Emacs Carnival May 2026 wrap-up: "May I recommend…"
  • Sacha Chua: Transcript of chat with Matei Candea about Emacs and AI
  • This perfect text editor doesn't exist (15:57)
  • From TECO to Neovim: 50 Years of Text Editing on Unix and Linux (Reddit)
  • PceEmacs is an Emacs written in Prolog instead of Lisp! It also seems to support LSP (Reddit)
• Emacs Carnival: Underappreciated Emacs Builtins:
  • Emacs carnival: rec mode, an all-text database system (@ericsfraga@fediscience.org)
  • Jakub Nowak: Radical Builtins
  • Emacs DWIM case commands by spnw
• Other:
  • phony.el: Define voice commands in Emacs (Reddit)
  • Bicycle for Your Mind: Much Ado About Emacs 013 - anddo.el (todos), substitute
  • Lars Ingebrigtsen: Todo Lists and Procrastination
  • jamescherti/inhibit-mouse.el 1.0.4 (Reddit, Irreal)
  • Charles Choi: Revisiting Emacs Keyboard Macros with a Mouse
  • Sacha Chua: Emacs PDF View: Replace current page with file using PDFtk
  • conquering the Emacs daemon - Blog In Isolation (@andyc@mastodon.me.uk)
  • tanrax/emacs-gpu: GNU Emacs with a GPU-accelerated display backend · GitHub (@andros@activity.andros.dev)
    • emacs-devel re: overlap with Canvas patch, can't accept LLM-generated contributions
  • emacs | extensions.fcos.fr (Fedora) (@alcarney) - emacs sysext for Fedora image-based systems
  • I built a floating HUD for Emacs, rendered in Rust egui via WASM (Reddit) macOS
  • Charles Choi: Opening macOS Finder Folders in Emacs with Scrim (@kickingvegas@sfba.social)
  • Damn! Emacs Regex problem | Unixbhaskar's Blog (@unixbhaskar@fosstodon.org)
  • самый хайповый гайд на Emacs (15:40)
• Emacs development:
  • emacs-devel: markdown-ts-mode and markdown-ts-view-mode demoted on the release branch
  • project-vc-dir: Use truenames
  • (Fmarkers_in): New function (bug#81153)
  • Support Ansible messages in compilation-mode
• New packages:
  • bluesky: A Bluesky client (MELPA)
  • cui: AI-LLM chat blocks for org-mode (MELPA)
  • desert-theme: A warm earthy port of Vim's desert theme (MELPA)
  • flamegraph: Flame graphs for Emacs's native profiler and folded stacks files (NonGNU ELPA)
  • sleek-modeline: Minimal and elegant modeline (MELPA)

Links from reddit.com/r/emacs, r/orgmode, r/spacemacs, Mastodon #emacs, Bluesky #emacs, Hacker News, lobste.rs, programming.dev, lemmy.world, lemmy.ml, planet.emacslife.com, YouTube, the Emacs NEWS file, Emacs Calendar, and emacs-devel. Thanks to Andrés Ramírez for emacs-devel links. Do you have an Emacs-related link or announcement? Please e-mail me at sacha@sachachua.com. Thank you!

You can e-mail me at sacha@sachachua.com.

If you have a numeric keypad¹, try this in the *scratch* buffer: enable numlock and press the zero on the numeric keyboard (Num-0). Then press the zero located between the alpha keys and the function keys (0). Okay, you see 00, no big deal.

Why do I bring this up? Emacs interprets Num-0 keypress as <kp-0> while it interprets 0 as 0. This means that you could bind Num-0 to a function without affecting the other 0. You could configure Num-0 to insert "zero" by entering and evaluating this in the *scratch* buffer:

(keymap-local-set "<kp-0>" #'(lambda () (interactive) (insert "zero")))

That's a trivial example, of course. But it implies that you can have ten more keys to play with. Similarly, the arithmetic operator keys on the numeric keyboard differ from the "regular ones" that are grouped with the alpha keys. They can be bound to functions, referenced as <kp-add>, <kp-subtract>, <kp-multiply>, <kp-divide>. But these also accept the standard C- M- S- modifier keys, which gives you twelve more possibilities. This is true also for the Insert key <kp-insert> and the Delete key <kp-delete> that double as Num-0 and Num-., respectively.

I have a "Calc" key above the numeric keypad. Unfortunately I can't seem to use it for anything in Emacs -- it opens the OS's calc.exe program regardless of what modifiers I use with it. This is a shame because it would be the ideal mapping for M-x calc. Perhaps this can be altered in BIOS.

But I do use my Win key as a modifier (sometimes). And I've heard that the Caps Lock key can be repurposed. These are topics for other posts.

Daniel Mendler, who took over as maintainer of the world’s best RSS reader, Elfeed, has announced the release of Elfeed 4.0.0. You can read the Change File to see what’s new but the most important point for me is that the maintainership of Elfeed has successfully transitioned from Chris Wellons to Mendler.

When Wellons announced his retirement from the Emacs ecosphere, I, and I’m sure others, had a moment of apprehension. We all wondered if anyone could fill Wellons’ large shoes. I’m happy to say that Mendler has shown himself up to the task and is doing a great job moving Elfeed forward.

As I’ve said before, I consider Elfeed an almost perfect RSS reader. It’s easy to configure it to operate the way you need it to. One of Mendler’s changes that I really like is the ability to pop into EWW if you need to. I use it from the default Elfeed text buffer but also from the WebKit mediated display if there are too many ads and blinkenlights on the default page. As I’ve said before, I have a growing appreciation of EWW and am a bit surprised to find it becoming one of my go to tools.

The important point, though, is that if you’re an Emacs user who has an RSS feed, you should definitely try out Elfeed. You won’t, believe me, want to go back.

On June 18, I'll chat with Ross Baker about Emacs and life.

<2026-06-18 Thu 10:30>–<2026-06-18 Thu 11:30> America/Toronto = Thu Jun 18 1030H EDT / 0930H CDT / 0830H MDT / 0730H PDT / 1430H UTC / 1630H CEST / 1730H EEST / 2000H IST / 2230H +08 / 2330H JST

• Blog
  • Posts tagged #emacs
• Emacs config
  • Emacs Early Init
  • Khlav Kalash Emacs
  • Crab Juice Emacs
  • Starter Emacs configuration

This session will be recorded, and I'll update this blog post with notes. https://sachachua.com/blog/2026/06/emacs-chat-with-ross-a-baker/

Find more Emacs Chats or join the fun: https://sachachua.com/emacs-chat

You can e-mail me at sacha@sachachua.com.

JTR over at The Art Of Not Asking Why describes a problem—and its resolution—that I didn’t know existed. The TL;DR is that photographs taken with an iPhone are always captured in landscape mode but Apple’s software detects portrait photos and corrects the orientation on the fly.

That leads to the problem: when iPhone portrait mode photos are shown on Linux using Org mode they are shown in landscape mode. You can get the details from JTR’s post.

The fix is pretty easy. He uses the mogrify tool of ImageMagick to auto-orient the photos based on their EXIF data. Since he’s viewing these photos in Org mode he wants an easy way of making the conversion from within Emacs. That’s a perfect job for Álvaro Ramírez’s dwim-shell-command, which JTR uses.

Take a look at the code and see how simple it is. Even if you aren’t an Elisp expert, it’s easy to do things like this with dwim-shell-command right from Emacs.

Emacs

Org-Mode and the Capture System

Org-mode has a capture system. You can be in any file in Emacs and invoke the capture system. Press a few keys and add text to a org heading in any file that you have set up a capture for.

It is easy to set it up. Firstly you assign a keyboard command to the capture system. In my case,

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

Org-capture

You get this.

Journal Entry

You press a key. Let’s say you want to add a journal entry. Press j and get this.

Type what you want to say in the buffer and when done, press ⌃C ⌃C. This saves the additions to the journal and closes the buffer. Leaving you in the buffer you were in before you invoked the capture function.

My setup for the journal capture looks like this:

("j" "journal" entry (file+datetree "~/Dropbox/org/diary2026.org")
"* %<%R: >\n%? \n" :empty-lines-before 1)

This is the code-snippet which does the heavy lifting. "* %<%R: >\n%? \n"

The explanation:

• *: Creates a level-1 heading.
• %<%R: >: This is a time format code. It inserts the current time in 24-hour format (e.g., 21:45: ).
• \n: Inserts a line break (a new line).
• %?: This is where your flashing cursor will start, you can begin typing your journal entry without having to move the cursor yourself.

If you set up a capture system, you can easily add content to files without having to open them.

It is one of the useful features of Org-mode.

Tweaking the Capture System for Bookmarks

I paid for lifetime access for pinboard.in. But I get the feeling that this project is on maintenance mode and the developer has moved on. It still works but I want to stop relying on it and move my archived bookmarks to a plain-text Org file. I started a bookmarks.org file with this structure:

Bookmark

I came up with a capture template:

          ("b" "Bookmark" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Bookmark")
           ,(concat "* %^{Title}\n")
           :empty-lines-after 1)

The capture would put the entries under the Bookmark header and I would refile the URL’s into appropriate sections periodically. Worked for a while. I learned more about capture templates and realized that I could lessen my work by filing the URL’s into their appropriate sections at the time of capture.

Org-capture

I didn’t like that. I wanted to be able to file the URL under it’s relevant heading when I captured it Now when I invoke capture I get this.

Bookmark Choices

Press b and I get this.

I can press the relevant key for the section I want and then paste in the URL. It gets inserted to the appropriate section.

Makes it easy.

This is an excerpt from the relevant section in my init.el.

;; org-capture
(use-package org-capture
  :ensure nil
  :bind ("C-c c" . org-capture)
  :config
  (setq org-capture-templates
        `(("b" "Bookmark Templates")
          ("bc" "Computer" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Computer")
           "** %?"
           :empty-lines-after 1)
          ("be" "Emacs" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Emacs")
           "** %?"
           :empty-lines-after 1)
          ("bm" "Misc" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Misc")
           "** %?"
           :empty-lines-after 1)
          ("bp" "Politics" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Politics")
           "** %?"
           :empty-lines-after 1)
          ("br" "Religion" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Religion")
           "** %?"
           :empty-lines-after 1)
          ("bs" "Shop" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Shop")
           "** %?"
           :empty-lines-after 1)
          ("bw" "Writing" entry
           (file+headline "~/Dropbox/org/bookmark.org" "Writing")
           "** %?"
           :empty-lines-after 1)

          ("j" "journal" entry (file+datetree "~/Dropbox/org/diary2026.org")
           "* %<%R: >\n%? \n" :empty-lines-before 1))))

This feature is one of the many that makes me love Org-mode.

Tweaking Org-mode

I am used to outlining programs. I have been using them for a long time. There is muscle memory build up over the years and I wanted to bring those into Org-mode. I am sure that the OG’s of Emacs are used to the Org-mode keybindings but I wanted to feel more comfortable using it. That comfort would increase if I used the keybindings I am used to.

New Org Header Outside/Inside

I wanted the new heading either to be a sub-heading within the current heading which conceptually is a daughter to me. Or the heading to be on the same level as the current heading I am under, conceptually a sibling. The third alternative, the new heading would be mom. That is a heading level higher than the one I was on. I wanted to be able to press a keyboard command and be at the start of the text of the new heading, mom, sibling or daughter. This piece of code does that:

(defun my/get-org-level-at-point ()
  "Find the level of the headline the cursor is currently inside of by searching backward."
  (save-excursion
    (beginning-of-line)
    ;; 1. Check if the CURRENT line is a headline
    (if (looking-at "^\\*+")
        (length (match-string 0))
      ;; 2. If not, search backward for the nearest headline
      (if (re-search-backward "^\\*+" (point-min) t)
          (length (match-string 0))
        0))))

(defun my/org-insert-child-headline ()
  "Insert a new headline that is a child (Level + 1) at the end of the current subtree."
  (interactive)
  (let ((level (my/get-org-level-at-point)))
    (if (> level 0)
        (progn
          (org-end-of-subtree) 
          (newline)
          (insert (make-string (+ level 1) ?*) " "))
      (user-error "Not inside an Org headline"))))

(defun my/org-insert-sibling-headline ()
  "Insert a new headline at the same level at the end of the current subtree."
  (interactive)
  (let ((level (my/get-org-level-at-point)))
    (if (> level 0)
        (progn
          (org-end-of-subtree) 
          (newline)
          (insert (make-string level ?*) " "))
      (user-error "Not inside an Org headline"))))

(defun my/org-insert-promoted-headline ()
  "Insert a new headline one level higher (Level - 1) at the end of the current subtree."
  (interactive)
  (let ((level (my/get-org-level-at-point)))
    (if (> level 0)
        (let ((new-level (max 1 (- level 1))))
          (org-end-of-subtree) 
          (newline)
          (insert (make-string new-level ?*) " "))
      (user-error "Not inside an Org headline"))))

Tweaking Some More

I am fond of the keybinding M-<right> and M-<left> as navigation keys in Emacs. In Org-mode it is bound to org-metaright and org-metaleft. That didn’t sound good to me. I was used to C-s-<right> and C-s-<left> for this function. Similarly M-<up> and M-<down> didn’t make sense to me. Too many years of using C-s-<up> and C-s-<down> for this function. So I changed them.

And I added keybindings for the functions I talk about in the previous section.

(use-package org
  :bind (:map org-mode-map
              ("M-s-i" . my/org-insert-child-headline)
              ("M-s-s" . my/org-insert-sibling-headline)
              ("M-s-o" . my/org-insert-promoted-headline)
              ("C-s-<right>" . org-metaright)
              ("C-s-<left>" . org-metaleft)
              ("C-s-<up>" . org-metaup)
              ("C-s-<down>" . org-metadown))
  :config
  ;; Optional: Unbind originals
  (define-key org-mode-map (kbd "M-<right>") nil)
  (define-key org-mode-map (kbd "M-<left>") nil)
  (define-key org-mode-map (kbd "M-<up>") nil)
  (define-key org-mode-map (kbd "M-<down>") nil))

This is all I have for today.

macosxguru at the gmail thingie.

Update: Howard Melman improved the unbinding code with this alternative:

  (keymap-unset org-mode-map "M-<right>")
  (keymap-unset org-mode-map "M-<left>")

Note: I had help from Ollama with the code.

I needed to replace a page in a PDF with another PDF. This was a bit of an annoying process on my iPad involving copying and pasting pages in Noteful and then re-exporting them as a PDF, but it was easy to do in Emacs thanks to pdf-tools and PDFtk.

;;;###autoload
(defun sacha-pdf-view-replace-current-page-with-file (file)
  "Replace the current page in PDF View with FILE.
Requires pdftk."
  (interactive "FFile to insert: ")
  (let ((temp-file (concat (make-temp-name "pdf-view") ".pdf")))
    (call-process
     "pdftk"
     nil nil nil
     (concat "A=" (expand-file-name (buffer-file-name)))
     (concat "B=" (expand-file-name file))
     "cat"
     (format "A%d-%d"
             1
             (1- (pdf-view-current-page)))
     "B"
     (format "A%d-end"
             (1+ (pdf-view-current-page)))
     "output"
     temp-file)
    (rename-file temp-file (buffer-file-name) t)))

You can e-mail me at sacha@sachachua.com.

Sebastián Monía¹ offered some alternatives to the exeln function that I posted on June 4.²

First, he pointed out that there's no need to bind asynch with the let function. Instead he suggested that I use (when arg "&") to append the ampersand when there's a prefix argument. Thus, shell-command can be called this way:

(shell-command (concat
                (buffer-substring
                 (line-beginning-position) (line-end-position))
                (when arg "&")))

Second, call async-shell-command rather than shell-command with the "&" as suggested in shell-command's doc string, which says, "You can also use async-shell-command that automatically adds '&'."³

Third, use thing-at-point from the built-in thingatpt.el library to return the line at point rather than calling buffer-substring.

(defun exeln (arg)
  "Execute current line as a shell command.
With prefix ARG, run asynchronously."
  (interactive "P")
  (funcall (if arg
               #'async-shell-command
             #'shell-command)
           (thing-at-point 'line t)))

And although he didn't mention it explicitly, he reworded the doc string -- it blends in seamlessly with the native functions' doc strings.

I set out to contribute to the Emacs community, but I'm getting so much more out of it than I expected! Thank you again, Sebastián Monía!

Sean Whitton writes to tell us that the first Emacs 31 pretest, emacs.31.0.90, is available for download. It’s been almost two years since the first Emacs 30 pretest came out so we’re pretty much on schedule for our yearly major release.

As always, Irreal wants to give a huge shout out of thanks to all the developers who work so hard to keep the Emacs development bandwagon rolling. They do all this for free so we each owe them a word of thanks and, as I always say, the drinks are on us if we find ourselves in the same bar as one of them.

Whitton’s post has all the details concerning downloading and verifying the latest tarball. If you don’t mind living on the edge, give it a try and report any problems.

After adding floating and inline tables of contents in BlogMore the other day, it was time to update blogmore.el to include commands to toggle the related frontmatter.

So, with the release of blogmore.el v4.6.0, two new commands are now available:

• blogmore-toggle-show-toc toggles the show_toc frontmatter property.
• blogmore-toggle-show-toc-inline toggles the show_toc_inline frontmatter property.

Both have also been added to the transient menu so they're easy to discover and use.

Spam is an eternal problem, and while SpamAssassin is pretty good (I get around 700 mails per day, of which 670 are rejected as spam), there’s still some stuff that persistently gets through. A goodly portion of that is traditional random spam from random accounts, and there’s not much to be done about that, but there’s a recent trend of legitimate-looking things coming from persistent accounts — like BackerHome and BackerHive.

I’m guessing that eventually these will get so bad reputations that they end up on RBLs and will disappear into the mists, but meanwhile… I just thought that there should be a mechanism in Gnus to split these message to the spam group — without having to do much work.

Tada!

It’s a small package, and you can find it on Microsoft Github. It’s basically a tiny minor mode that adds a couple of commands, so you just hit z, check the entry (or not) and then C-c C-c.

(There’s also a command to edit the split data if things go off the rails, or just because you want to.)

B t to check the split trace, as normal.

So there you go. May your inboxes be slightly less spammy.

(And it’s fun doing some Gnus work again for the first time in years… I’ve forgotten what all the functions are called, though, so I had to use Claude to remind me. *gulp*)

The following exeln function passes the current line to the system shell, which executes it, thus EXEcuting LiNe.

On Windows x86, my GNU Emacs has shell-file-name set to cmdproxy.exe, which is provided by x86_64-w64-mingw32, with which Emacs was compiled.

shell is invoked synchronously by default; a prefix argument can change this to asynchronous.

In the video below, point is on a line of text that would print the contents of hello_whirled.txt when entered at the Windows command prompt (or DOS prompt). I press C-c x, which is bound to exeln. The command is executed and the output is shown in *Shell Command Output*, the default buffer used for synchronous output from shell-command.

(defun exeln (arg)
    "Execute the current line as a shell command.
With prefix arg, operate asynchronously, same as calling
(shell-command COMMAND) where COMMAND ends in '&'.
Otherwise, execute synchronously."
  (interactive "P")
  (let (asynch)
    (if arg
        (setq asynch "&"))
    (shell-command (concat
                    (buffer-substring
                     (line-beginning-position) (line-end-position))
                    asynch))))

2026-06-04 Add demo video

“No-code automation” has been in Emacs far longer than its usage as a term of art. Better known as keyboard macros, this feature has allowed Emacs users to achieve their bespoke needs for decades, all without needing to know a whit about Lisp. I can testify to this personally: though I’ve been using Emacs since the early 90’s, only in the past three years has writing Elisp played any part in it. For most of my Emacs journey, I got by with just making keyboard macros.

If you’re unfamiliar with them, here are two links you should get to know:

• The official Emacs manual for keyboard macros ((emacs) Keyboard Macros)
• Mickey Petersen’s post - “Keyboard Macros are Misunderstood”

My addition to the knowledge of those posts is to boost this fact: mouse events can also be captured by a keyboard macro. If you know where a command is in a menu, you can also record clicking on it. I think the ability to combine both keyboard and mouse events in a keyboard macro is compelling, so much so that I decided to emphasize this in Anju.

The recent Anju v1.5.0 release added the menu “Tools › Macro Recorder” to the menu bar as shown below.

With this, mouse enthusiasts can create and run keyboard macros without need to recall keybindings or deal with inconsistent command naming, as observed in Petersen’s post.

One thing that I TILed about keyboard macros in building this menu was the command list-keyboard-macros (see (emacs) Kmacro menu). This command is available in the “Macro Recorder” menu as the item “List macros”. This lets you manage multiple keyboard macros that have been defined during a session.

If this interests you, I invite you install Anju from MELPA and give it a try. Let me know what you think!

James Cherti has a new version (Release 1.0.4) of his inhibit-mouse package available. As the name suggests, it disables the mouse while you’re using Emacs. I’ve written about inhibit-mouse before. As I said in my previous post my first thought was that I don’t need this because I’ve already trained myself not to use the mouse while I’m in Emacs.

The thing is, though, that I mainly use my laptop—a MacBook Pro—which has a trackpad for mouse operations. Since I often use my laptop on my lap while sitting on the couch, it’s easy to inadvertently touch the trackpad with my palm and change focus from one window to another. Turning off the mouse would eliminate that from happening. Still, I do use my trackpad to scroll Web pages and emails that are displayed with WebKit because there’s no other decent way of doing so. Happily, inhibit-mouse is very configurable and you can, in particular, disable it’s use in any major modes you like. That may solve my WebKit problem.

Inhibit-mouse is a reimagining of Steve Purcell’s disable-mouse package. Cherti claims inhibit-mouse has some advantages—such as being more efficient—over disable-mouse. Take a look at the repository to see what they are.

If you’re looking for a way to banish the mouse from your Emacs experience, this seems like a good way of doing so. You can even leave a couple of escape hatches if you need to.

I chatted with Ben Zanin about music, Org Mode, Emacs in terminals and on an Android, keyboards, elfeed, and more.

View in the Internet Archive, watch or comment on YouTube, read the transcript online, download the transcript, or e-mail me.

Transcript

Expand this to read the transcript

0:00 How Ben got started with Emacs

Sacha: I forgot to ask you how your last name is pronounced.

Ben: Oh, Zanin.

Sacha: This is Emacs chat number 25 and here I am with Ben Zanin. You have a math background and now you're in IT. Where did you encounter Emacs in the journey?

Ben: So the reason I have a math background is that I wanted to get into programming language design and at the time so that led me over to lambda calculus and that kind of thing and at the time it was at the time I was getting into university in like 2005-2006 It was impossible to get into the computer programs, but I could get into math. I figured that would move me in the direction that I wanted to go in, so I did. Got to third year, and then every professor who taught any of the courses I cared about all left the faculty at the same time.

Sacha: Oh no!

Ben: Yeah. Anyhow, that's a different story. But yeah, I got into Emacs because in the process of learning about Lambda Calculus, the Lisp weenies found me. And yeah, I spent a bunch of time learning about that. And it wasn't until like 10 years after I got into Common Lisp and Scheme that I actually got into Emacs at all.

Sacha: That's interesting. Usually people, like, if they're doing Lispy things, they get into Emacs right away because Lisp. But okay, so 10 years after. You're already well-used to parentheses at that point.

Ben: Yes. But I guess it wasn't until about ten years ago, like around 2015 or so, that I started really getting into Emacs. I would still consider myself to be a beginner on that front.

Sacha: Oh yeah? So what got you to get into it more?

Ben: I found that I was looking for more structured data management processes. Basically, I was looking for personal information management. And I kept bouncing off Emacs because I wanted to get into those tasks, but Emacs was such a rich learning process that I kept getting sidetracked, so I kept bouncing off of it.

2:19 Ben got into Emacs because of twittering-mode

Ben: But I have to admit that one of the things that originally actually got me into Emacs was twittering mode. Oh yeah? Because I was looking for a tool that would let me, we'll probably get into this later in the chat, but I was looking for a tool that would let me keep a larger window of context about the conversations that I've been in. The Twitter apps and the Twitter website implemented a really narrow window. I wanted to be able to search back a couple of weeks for stuff that I had seen or talked about previously. Twittering-mode gave me the ability to keep days or weeks of context in a single buffer that I could then immediately search. So I didn't actually get into Emacs as a text editor, I got into it as an application platform, and then gradually learned the rest of it. This is actually fantastic. So I kind of stuck around after that.

Sacha: That is the first time I've heard of someone coming to Emacs because of Twitter.

Ben: No, it's deeply embarrassing.

Sacha: No, it's wonderful. I love that there's just so many reasons why people come and the fact that you could find something that would let you take those notes and see that context and reply to it, and even, as I see in your config, work around slow keyboard response issues.

Ben: And also the fact that that's still in the config despite Twitter itself... I think I abandoned it in 2017, but it takes me a little while to rip things out of my config.

Sacha: Yeah, I see you're a lot more active in Mastodon these days. I see your Monsterdon posts scrolled by my feed every so often. Yeah, so we dove right into that because a lot of the stuff in your config is interesting and your workflows too. My idea for these Emacs chats is to show people the kind of stuff that isn't immediately obvious to newbies when they're looking at someone's config. Because a lot of the stuff is new workflows and how the keyboard shortcuts work together and how this stuff fits into your life. That's not immediately obvious from the code. I've taken a look at your config, but before we jump into the gazillion things I wanted to ask you about, are there things that you particularly love about your Emacs workflow?

4:30 Emacs as a media playback platform with Versuri and Mpdel

Ben: I'm probably going to get a little bit of deserved flak for this, but I use Emacs a lot as a media playback platform. I spend a lot of time using Emacs to listen to music through MPV. And I've got some integration with Versuri, which lets me... I think you've seen those customizations where what I've done is I've kind of duct-taped the two together. Versuri is an Emacs package for being able to quickly search through lyrics for songs. What I've done is I've bound Versuri to the point where I've pulled up a page of lyrics, I now have a hotkey that bounces me over to a search of my MPD library for where that song is, and vice versa. I've got MPD rigged up so that when I've got a song currently playing, I can bounce into Verisuri to display the lyrics for that particular song. Something you probably have not seen in my config yet because I haven't finished it yet... What I'm working on is actually integrating Org Mode with MPD, because I'd really like to be able to streamline my process where occasionally when I'm listening to something, I'll take notes either about the lyrics or about the song. I'd like to be able to link from Org Mode directly to either that song, that album, or that particular timecode. I don't have that yet, but I'm working on it. I think I'll probably lean on it quite a bit once I have it.

Sacha: Yeah, yeah. I saw your tweet from May, I think, where you're talking about coming up with this way of taking notes. think if you come up with maybe a custom Org Mode link type that can store the annotation and then let you go to it, I think that would be really interesting. Especially if you figure out, okay, like, are you taking notes in the album? Are you taking notes on the song? Are you taking notes on this moment in the song? That could all be very cool.

Ben: Actually, do you mind if I share my screen?

Sacha: Please.

Ben: So one of the things I wanted to kind of note was... Let me... Oh yeah, this is actually going to be further embarrassing. I'm a terminal Emacs user.

Sacha: I saw. Can you increase the font size, though?

Ben: Absolutely, yeah.

Sacha: Resizing your terminal so it's smaller makes everything look bigger...

Ben: Is that better?

Sacha: More. Some of us are older. Thank you.

Ben: One of the things that's kind of unusual about my MPD configuration is I've got a satellite config. Sorry, the line wrap is a little bit off here. What this means is that I have... the household file server maintains the MPD library, but I've got multiple playback nodes around the house. What that lets me do is...

Sacha: You can play stuff on this...

Ben: So what this means is that I'm controlling the... well, in this case, that's a little MeLE Quieter3C that I've got in the living room that's kind of like the the home media server, the home playback machine. Fundamentally, I'm an ops guy, I'm a sys admin, and I've got, unfortunately, a fleet of machines around the house. What this lets me do is easily control each one of them. Instead of each one maintaining its own library of music files, the file server itself indexes them, which means that library updates are almost instantaneous, instead of having to read over the network to pull metadata out of each individual file. So having a satellite setup lets me... The real benefit is that MPD tracks albums, directories, and files as URLs. That means that I have a single global namespace of URLs for all of the media that's currently in the library, which means that I can annotate from any machine, but have it mean one thing. It makes it convenient for navigation, but it also makes it convenient for keeping notes, which I'm currently doing manually and working on those Org link types to be able to make it a little bit more smooth than it currently is.

Sacha: So you've got your central store of music files. You've got URLs for them so you can talk about them. That's just one identifier per song. You've got multiple speakers that you can use your completing interface to say, okay, I want to play this over there. You have Emacs controlling all of that.

9:13 Emacs on Android with Termux

Sacha: Now, is that Emacs on your laptop and you just take it around and you say, okay, I'm going to sit in the living room for a little bit or whatever and play there. Or do you... Ah, there you go. That's what I was going to ask. All right. So Emacs on your phone. The Android port or Termux?

Ben: I have both installed. I think you actually saw this a few months ago when I was running performance comparisons between the Termux version of Emacs and the native port, and found that the native port generally ran anything CPU-intensive roughly twice as fast. But I still use the Termux version because it's... I'm not sure if you played around with the Android terminal virtualization layer at all, but it's not great. I really appreciate the integration that Termux gives me with Android features. For example, being able to query the sensors, such as GPS or temperature sensors, and I can actually pull those in from the Emacs side. And that's something I kind of want to get into.

Sacha: What do you think of using the temperature sensors for? What can Emacs do with that?

Ben: It's not so much the fact that I use the temperature sensors as that when I pull the sensors, that's the most remarkable value that I get out of it. But one of the interesting things is the barometric pressure sensor, which gives me height, which matters because when I'm out and about and if I stop to record an entry in my journal, for example, I'll just pull the sensors and dump them into the header in the entry that I'm writing. The barometric sensor, I'll get the GPS, so that'll tell me what the actual height is at that location on the earth. The barometric sensor also gives me a little bit of insight into the weather. So it's not so much the temperature sensor is what my temperature is, but just like if it's a hot day or not.

Sacha: I am very curious about that setup. So if you happen to share your, I don't know, Org capture for Termux that includes all these things... You don't have to show me the actual stuff, but you know, at some point I think other people will be curious about what kind of benefits they can get from running Emacs on their phones.

Ben: So, I mean, I guess I'll... One of the benefits that I get is the ability to keep shopping. So I'm a little bit of a militant cyclist. One of the things that I often do is leave

Ben: notes about things that I need to take care of in particular areas of the city. The nice thing is that I can just drop them directly in commits right as I'm going. So I often have a long list of updates that are from Emacs on my phone, just because it's convenient. All right. There we go for Monsterdon, in fact.

Sacha: Nice, nice. Then that's Syncthing or whatever else to just get it copied back to your laptop or just on your phone?

Ben: Straight Magit mode.

Sacha: Oh, yeah?

Ben: That's one of the things that I found was a little bit clunkier when I was running virtualized Emacs under the Android emulator and also the native Android port of Emacs. They are a little bit more troublesome to get Magit to work. Because I rely on that for syncing back and forth from my phone, that's one of the reasons why I stuck with Termux.

Sacha: Very cool, very cool. I like Termux's little bar of extra keyboard keys that you can have, so you can have a regular keyboard and then you can just have your Controls and your Alts and whatever on that little extra bar. Termux is quite interesting.

Ben: I think I'm probably pushing it harder than it is meant to be pushed.

Sacha: That's the fun of it. I don't exactly know how everything will shake out, but probably with Google trying to lock down the developer ecosystem in a few months, right? They're saying, oh, you know, it's got to be ADB in order to get these unsigned apps on. We'll have to see how it all shakes out. But I'm hoping Termux can survive because I like that one too.

Ben: Yeah, me too.

Sacha: Okay, so you've got interesting music, an interesting music setup with lyrics and playback and all that stuff. You've got your phone, which also runs Emacs and from which you can, you've also set it up so you can control your music from your phone?

Ben: Yes.

Sacha: Okay.

13:44 Keyboards and other devices

Sacha: When I was reading through your toots, I noticed you like to play around with other keyboards and other devices like the 8BitDo. Do you have any of that talking to Emacs too?

Ben: [Keychron B11 Pro is] the keyboard I'm currently using. I got this so I could keep it in my purse and just like walk around with it, but it turns out it's super comfortable and I'm accidentally using it as a daily driver.

Sacha: All right. Name-drop the keyboard for all the people who like the device recommendations.

Ben: It's a Keychron B11 Pro. It runs ZMK. ZMK, I suppose. And if you've seen me interacting with Pete Johanson on Mastodon, he's the lead developer of that firmware package. It's a little bit like QMK, except that fundamentally QMK is a polling architecture, and it works really well for very restricted microcontrollers. ZMK is interrupt-based, which means it is tremendously more efficient in terms of power draw. So if you want a Bluetooth keyboard, you should probably run ZMK on it. Anyhow, yeah, it's fantastic. And I do have a bit of a keyboard problem where I tend to...

Sacha: Many Emacs people have keyboard problems.

Ben: Right? I feel like I'm in good company right now.

Sacha: Yeah, yeah, yeah. So, devices, yep, gotcha. And this has become your main keyboard even for regular computing?

Ben: In the last couple of weeks, yeah. It's super comfortable. Because it's so flat, I can get away without having to use palm rests to actually keep in a decent posture, because of the curvature of it.. Like, it's an Alice layout. The key travel isn't too bad. It's actually quite comfortable. I found that I needed a little bit of acclimatization to get used to split keyboards. This one has roughly the spread of a split, but it seems to be easier for my muscle memory. So yeah, I didn't intend to leave it on my desk, but it stuck and has kind of stayed there for now.

Sacha: Does it have any special ergonomics for all the modifiers that we like to do? Or do you just use Caps as Control or whatever else?

Ben: Actually, I don't use Caps as Control and I actually really need to get into remapping that. ZMK has a very rich remapping story, as I expect you to imagine, from a custom firmware. The macros are intense, and you can get really deep in customization. I have done none of that on this keyboard yet, because it's only, I think, a couple of months old at this point.

Sacha: You've been settling in. As you said, this has been your main keyboard for a little while. Charlie Baker says, "yeah, I love the split keyboard. Recently bought one myself. I was getting so much neck pain, you know, shoulder and neck pain from so many hours keeping hands close together." But the split lets his shoulders relax. So probably you're getting the same, like, ha, my arms.

16:44 Benefits of a split keyboard

Ben: The two things that I first noticed when I moved to a split keyboard was one, my wrists started feeling a lot nicer and two, I was immediately able to bench press like 20 pounds more the next week. It was amazing how much of a difference it made and it showed up in the data.

Sacha: Wow. There was a weightlifting talk at EmacsConf last year, I think. So there's a surprising overlap between the people who are checking their weightlifting stats and the people who are into Emacs. Naturally, with Org Mode. There you go.

Ben: Let's not look at those numbers too closely. I'm not too proud of a bunch of them. But yes, I find that Org capture templates let me keep on top of that and not really think about it, which is great because you don't want to think about it. You want to gather the data and think about it separately so that you can stay emotionally divested from what the numbers mean.

Sacha: I know. I'm totally happy to dig into the Org capture, especially if you do any graphing. People always love graphing their progress, right? But if you're like, I don't really want to show my numbers at the moment, that is also understandable and okay.

Ben: I don't, I'm afraid. Sorry.

Sacha: That's okay.

Ben: It took me a couple years to get used to being on camera at all. I don't really like my appearance very much. I'm working on that, as you can see. I've had to work on that to be able to work remotely. It's a work in progress. I'm getting through it.

Sacha: You know us. We're very much focused on text. In fact, you even use Emacs in the terminal. That's very text-y.

18:22 Meeting workflow

Sacha: One of the interesting things actually that I wanted to ask you about since you mentioned meetings is you probably also have the role of designated note-taker. You mentioned in one of your toots that you take notes and people are like, what are you doing that in? How are you taking your notes? And it's Emacs.

Ben: Yes, so actually that's one of the things I should lead off with as an apology. I probably won't be able to share many of my capture templates because I don't use them in my personal life very much. They're mostly on my work machine. I've got capture templates for impromptu meetings where it's just like an exploratory, we have a problem we need to solve, we're kind of talking through a discussion, a separate capture template for meetings with agendas to make sure that we stay on them and that we log decisions, and a separate set of templates for... So I have a team of direct reports and they each have different cares and different topics that we're working to develop in their professional careers. I find that it's really useful to be able to keep some continuity between our conversations. It also makes it very easy to export that entire dataset, share it with them to make sure that they can consult it at the same time. If I got anything wrong, I can fold their corrections in. But all of those templates, unfortunately, are on my work machine.

Sacha: We'll just sketch out the general idea in abstract details and then people who want to implement it for themselves can fill in the blanks. For example, when you're having a meeting with your direct reports, are the tasks related to them in an Org agenda? Are you using dynamic blocks? Is it tracked somewhere else or is it in Org?

Ben: It's straight in Org mode. So most of the touch points that we have are more about professional development and their cares and concerns, rather than specific deliverables. Usually deliverables we manage at a team level. But if there are specific things that individuals are working on, they will be in to-dos under their subheadings in a way that show up on the agenda if we have assigned deadlines for them. But generally, if there's a deadline on a task, it's because I'm doing something and they need to track it, or they're doing something and I need to track it. If I'm the only guy using Emacs, then Org Mode won't work for that, so there aren't a lot of those. But if it's just something that I need to check up on to make sure that something that... Like they've got planned leave for example, or they have a cousin's wedding that they need to go off to, or something that I just need to keep in my brain that's not necessarily deliverable, then it would be appropriate to keep that in a place where it'll only show up on my agenda. So that's the kind of decision making that I apply there.

21:11 Narrowing

Sacha: And you mentioned you have a subheading, I guess a subheading per person or sort of... Or do you use tags to keep track of something that might touch several people?

Ben: Usually a section per person, and that's more of a convenience than anything else. That lets me narrow to just that subheading and share my screen during the meetings. Then I don't have to worry about accidentally leaking anybody else's information into the screen share or anything like that. Obviously we let off with conversations about them being all right with that. But the ability to very clearly and simply delineate "This domain of my notes pertains to this person" and being able to be confident and share that confidence that there will be no leakage means that we can explore topics and talk about them in a way that might otherwise be a little bit more restrictive. So being able to do that simply, and being able to establish a very clear delineation around whose information belongs where and where it should be shared turns out to be pretty valuable.

Sacha: Yeah, and that's a technique I think that especially people who are new to Emacs and who aren't used to narrowing and widening might not know how to use effectively. I think narrow is even one of the commands that's disabled by default. You've got to say, yeah, you know, I'm not scared. I know what to do.

Ben: Yeah, it's kind of bizarre to me that it is, but yeah.

Sacha: I can imagine people accidentally triggering it and they're like, oh no, the rest of my file is missing. But if you know how to narrow to a region, and Org even has those commands to easily narrow to a subtree... I think it's even part of the default speed command so you can trigger it right from a heading. But it's great for that kind of restriction.

22:58 There's even an internal Slack channel about Emacs at Ben's company

Sacha: Okay, so the reason why I was asking about that is because some people are working with people who are not using Emacs, so it's very interesting to see what the kinds of... It's very rare for people to work with other people who actually use... Are there any other Emacs people in your company, for example?

Ben: There's an entire Emacs Slack topic about that, yeah. It's kind of great.

Sacha: What is that like to have co-workers who do Emacs? Because this is a rare experience.

Ben: It's super cool. It's also neat to see the very, very different ways that people use it. But yeah, oftentimes people will talk about problems that they have with particular internal tools, and somebody's like, oh yeah, go check out this repo on GitLab that I published last week where I got sick of it and decided to solve that problem categorically. It's actually super cool. And some of the folks at... Generally, I tried not to mention my current employer at any point. Obviously, it's not secret. It's in the init file. But yeah, I don't tend to get into that deeply. But some of the other people who work at my company, they maintain venerable Emacs packages. So it's awesome to be able to go and talk with some of the folks who I've been working on the code that I've been using for a decade and we are now coworkers. It's lovely.

Sacha: Oh, that's so nice. I'm glad you have that kind of little community in there.

Ben: Yeah. Bunch of nerds.

Sacha: So I suspect some people will be looking up your company after this. I think it's also mentioned in LinkedIn and sort of like, okay, let's see if there's any job openings.

Ben: If it's mentioned on LinkedIn, that is somebody else. I haven't logged into LinkedIn in 15 years and I never will.

24:50 Ben keeps Org capture templates as individual files and adapts them to different meeting flows

Sacha: We do have a question from Shae. Shae is asking, how do you make a capture template to stay on agenda and record decisions? You got any tips for that? I'm guessing this is more of a human thing rather than an Org thing, but maybe you have some ideas on how you keep something on track.

Ben: So I'll actually push back on the "It's a human thing rather than an Org thing". I strongly believe that one of the real values of Org Mode is that it's a very plastic system. Fundamentally, I think that it is a human system because it allows you to express exactly those kinds of trade-offs in a really, really fluid way. I love the personal information management that Palm Pilots provided, for example, but it was pretty restrictive. One of the things that I love about Org Mode is that if you find that a particular person has a particular conversation style, it's really easy to modify your Org Mode capture templates to be able to capture that particular flow that you have with that person. Or with a particular group of a recurring meeting, for example, that tends to flow in a particular way. Super easy to update the templates that I use to capture those particular meetings to make it easier to match the general conversation flow with the notes that I will be taking about it.

Sacha: Wow, that sounds pretty sophisticated.

Ben: Well, I mean, that's the thing. It's not sophisticated. It tracks the human process very easily. So it's really lightweight. So you don't have to have a lot of sophistication to make it very, very useful. You just have to have a feedback loop that you can tune every time with one or two minutes of effort. And that's one of the reasons why I depend on Magit mode so much is that it lets me track those things. But yeah, to answer Shae's question about how do I track those particular things. So if it's a meeting where one of my direct reports has a particular set of topics that we tend to investigate, like somebody who's concentrated on career growth. So we're talking about the areas in which we want to see development. I'll absolutely update the capture templates for that particular person to say, all right, here's what we talked about last time. Here are the things that were done between our last two conversations about how we move in that direction. Were they successful or not? Did it require a lot of effort? So was it something that more effort should be put into to be able to drive down the work over time, to be able to produce those results? But yeah, that goes into the templates and that goes into the cadence of conversations that we talked about in Capture.

Sacha: So that's really interesting. You modify the capture templates with the notes that you want to have easily available the next time you chat with them.

Ben: Exactly, yeah.

Sacha: The capture templates are still defined as a setq somewhere in your thing, or are you going into the customized interface?

Ben: So I actually keep the capture mode templates as raw files that are referred to, and that makes it easier to version them in a way that like, I mean, sure, like my Emacs init file, if you look at the Git history of it, it has a whole bunch of different...

Sacha: I had not considered having capture templates as files files. It worked out really well.

Ben: So you can see that... It's a little bit hard to see with the font this small, but you can see that I've got a lot of changes to, for example, my init file, but keeping them in individual capture mode template files makes it a little bit easier to just look at the history of that particular file and see why particular changes were made.

Sacha: I'm going to try that. I think that's a great idea because it allows you to be a lot more granular about the notes.

28:45 Personal-scale software and the journey

Sacha: I saw in that very brief flash of your change log message that you like to write fairly detailed commit messages that talk about why a change was made instead of just "a new function, new command," very terse updates that I sometimes just try to get away with. Tell us more about that, because I think you've had a couple of toots about reading source code and reading commits.

Ben: Yeah. So I guess one of the things that I most appreciate about software in general, and specifically personal software, like personal-scale software that's been written by an amount of people that you could fit into a room to have a conversation about it... One of the things that I most appreciate about that is that almost all software written that way is fundamentally a diary about the way that a person learned how to solve a set of problems that they might not have known about when they decided to at the beginning. It's this fascinating process of tracking somebody's voyage through the problem landscape as they discover other people who have touched on topics that are tangential to the problem being solved by that software package. It's such a personal and fascinating experience to see somebody go from "I know just enough about a problem to be able to decide that I want to build a machine that works on it" to "I have this deeper understanding of how the problem actually exists in the broader set of things that people care about, oriented along the axis of what machinery can do to help solve parts of that problem." The commit logs for a program are like a map through that territory. It's wonderful to read. It gives you a lot of insight into the person doing the navigation. When you see 16 commits on December 24th of 2023, like, that person probably had a little bit of time to work on it. Then, when you see a bunch of commits that are 5 p.m. Monday to Friday, like, okay, this is probably done in a particular way. It's this deeply personal process of seeing how problems are learned about. I just really appreciate that.

Sacha: I think what you're saying about personal-scale software and getting a sense of people's journey as they learn to understand a problem and as they start to prototype a solution... Because you never quite come across the right solution the first time around. You're figuring things out, You're borrowing things from other people. I think that will resonate a lot with lots of people in the Emacs community, because Emacs use is so personal, as you mentioned when you were looking at the Slack channel. I was wondering, in your personal practice, as you figure things out, what kinds of things help you? Is it mostly a matter of actually sitting down and taking the time to write the literate programming stuff around the code blocks or the commit messages, or are there other tools or techniques that help you do that? Are there tools or techniques that help me write down your journey along the way as you think about the code? What's your practice? For example, when you come across something that you want to figure out, how do you go about doing it?

Ben: So it depends on how I'm approaching the project. One of the neat things about software is that it's a document and a device at the same time. You can care about it because of the thing that it does, or you can care about it because of the information that it captures. If I'm digging into a program because it does a thing that I want to learn, then I'll pay attention to the device aspect of it. That usually means that I'll start with its own documentation. If it has a man page, I'll read that. If it has user docs, I'll read those. Usually, I'll start keeping notes in an Org Mode file, because it's easy to hyperlink back to it and add my own annotations in parallel to the actual authoritative source. If I'm reading software primarily as a document, then I'll start by reading the source code and the commit logs, usually the most recent ones, and then I'll jump back to the beginning of the project and read upwards at the beginning, and then fill in the blanks iteratively, if it's a project that's small enough or has little enough history that I can do that. Again, I'll usually start an Org Mode file specific to that particular exploration that will let me organize my notes as I go. I really do rely on the external brain that I can keep in an Org Mode file. I tend to have a pretty decent long-term memory, but being able to bridge the gap between short-term memory and long-term memory is super, super useful. Leaving myself hints that let me dredge things back out of long-term and reload it into the hot cache of short-term really, really helps out, because that lets me maintain that flow state or get back into that flow state. When you've got like the whole program, all the context that you've absorbed up until now and the ideas of the areas that you want to investigate, being able to hot-reload all of that and then pick up where I left off is super useful. But the meat brain can't do it. I need the machine brain too.

34:07 vc-git-grep for finding notes again

Sacha: Tell me about this dredging up process. Are you a lots of little files person? A couple of large files? A project file, there's an Org file in each project that you look up? How do you find things, especially if you don't remember the exact words?

Ben: So it's usually like an Org Mode per category, and they get consolidated. Let me shrink this down a little bit. So usually it's an Org Mode category per file. If there's something super specific, then usually it'll live out in its own place until I get around to...

Sacha: I love that you have an Org File specifically for Mug Cake.

Ben: But that's the thing. It'll live off in its own thing until it gets integrated into the list where the long-term stuff lives. I promise this is pertinent to your actual question.

Sacha: No, no, this is very pertinent.

Ben: Usually, lots of little files while I'm still working on something, and then as that something becomes part of my larger life and has links to other things,

Ben: then it'll kind of get centralized into one of the Org Mode files that has a broader topic purpose basically.

Sacha: If it's very long-term and you can't remember the exact words to find something, how do you generally find find your notes?

Ben: That way.

Sacha: You start grepping various keywords and try to find it.

Ben: Yeah. So one of the things that I don't yet have turned on, and actually you inspired me to look into this, was so... Actually, do we have enough time? Yeah, okay. I'm just looking at the clock. One of the things that I wanted to get into was long-term searching and searchability. Yeah. So I use SQLite's indexing for a lot of things, and I really appreciate its porter stemming because it lets you search for stemmed words, which are kind of approximate matches, which is useful, but less useful than vector databases. You actually put a little bit of work into indexing topics based on vector similarity.

Sacha: Which I haven't gotten back to, so I'm glad to see you managed to experiment with it, see what you come up with.

Ben: I don't have anything to show yet, except that it's an interesting topic. Because I'm word-oriented, I will often remember individual keywords, or I'll have enough patience that I can sift through a list of potential keywords as I'm grepping for stuff.

36:55 Add keywords to make things easier to find again

Ben: If I find that my first three or four attempts at searching for a keyword don't find the topic that I'm looking for, once I do eventually dig up the topic, I will add those keywords that I was searching for just so I can find it next time, expecting that future me will probably behave more or less like current me. But yeah, being able to use a vector database to search for headings that include related topics instead of related words... I'd really like to get there. I'm not there yet, and I think that's going to be interesting and useful. I also think it's going to be challenging to represent Org Mode's hierarchical structure to restrict the training of particular vector sets to be able to cast an increasingly wide net for where I want the searches to run. I don't know how that's going to be solved yet, but I'm going to be looking into it.

37:47 Keybindings and terminals; wezterm

Sacha: @PuercoPop has a question regarding terminal Emacs. "Do you need to change any of the keybindings to avoid clashes with the terminal?" Some keybindings don't work on terminals, or some terminals already have these keybindings set.

Ben: So I have good news and bad news there. The good news is that... One of the terminals that I'm using right now on most of my systems is Wezterm. It's really good. I started off with [meant to say Kitty], and I kind of bounced off that project because of some of the behavior of the lead developers. I won't get too deep into it, but what I found is that Wezterm... It gives me very little friction that way. It doesn't have a lot of its own keybindings, and that's a relief. It means that I really don't have to... I don't think I've had to put any time into customizing Wezterm to get out of the way of Emacs or Screen. I should mention, I am running Emacs within Screen, so that introduces another layer. C-a a, for example, is beginning-of-line for me, even though C-a itself is the default Emacs keybinding. But yeah, I think that I ended up choosing terminal software specifically on that merit, so that it doesn't get in the way. That's actually one of the things that Termux is... The default Google keyboard keeps stealing key bindings. It'll update, and all of a sudden, I can't use a particular Alt key combination anymore, because now it invokes a Google keyboard shortcut for pulling things out of the Android clipboard, for example, which is really kind of annoying. But yeah, in terms of terminals on full-fledged machines, I generally don't have that particular problem. Except for... What was the name of it? It was... It was a zap-to on-the-screen package that alphapapa wrote, I believe, that I... Actually, let me just look it up. Yeah, Avy.

Sacha: Oh yeah?

Ben: So I wanted to start picking this up in 2021, and yeah, control colon doesn't work in terminals. So the mode itself is fantastic, and when I'm using it in a GUI Emacs, it's very useful, and I rarely use it now specifically because of that particular terminal problem. That is self-inflicted. That is not a problem with the package. That is a me problem. But yeah, I think this is the notable one that I bounced off of.

Sacha: Yeah, just trying to find the right, you know, a key binding that will pass. Because you can't get used to key binding in one system and then not have it available in other systems. It's just going to mess with your brain. So yeah, Ray points out, yeah, Google steals Control Shift K, which he uses to kill tabs to the right. So it's like, oh.

Ben: Infuriating.

Sacha: Yeah, yeah. And of course, none of the standard keyboards have a super key on the thing, so you can't just tack on another modifier that'll get through.

Ben: That's actually one of the reasons that I picked up this particular keyboard is Brian Carlson. Another Torontonian. He works on Git LFS and some other stuff. He was specifically looking for a keyboard that had a super key that he could remap. So four keys to the right of space, which this one has. And because it's ZMK, it's remappable. I think this might be suitable for his purpose, except that he wants a QMK keyboard, specifically because the development tools for QMK are packaged in W, and that's a plus for him. Anyhow, yes, I agree. Like, not having a super and a hyper key on a keyboard

Sacha: feels like like one of your fingers that are cramped up we need more modifiers well I mean you know pipe organ Tell us about that.

Ben: What is this? Oh yeah, foot pedals. Yeah, and I actually do have these wired into a little Atmel microcontroller running QMK. I honestly tried the foot pedal thing for a little while. It was hilarious. I did not find it useful.

Sacha: I don't have the hand-eye-foot coordination to do that thing at the same time.

Ben: Maybe if I had learned piano as a kid, it would have been good. But yeah, I don't seem to be able to do it. But I gave it the old college try and it was fun.

42:38 Timers: tea-timer, tmr

Sacha: Okay, I had a couple of things I wanted to ask about in your config. You have two types of timers. You have tea-timer and you have Prot's TMR. Do you use them for different purposes? What's going on here?

Ben: So I'm trying them out. I tried TTimer first because it was the first one that I found, and it was useful. I was actually using it in meetings because I would, when I was trying to keep us on topic, I would use that to remind us that, oh, we've got four other topics we need to get through. We're trying to give this one five minutes. We're running up on four. And it was just because it was super low overhead. It was easy to pick up. It was easy to have it displayed on my screen. And it didn't feel like I was... Running a chess timer on everyone. It's very subtle in the mode line. It was useful. But what I found was that when I was... Running multiple timers simultaneously. TMR, just the fact that you can list all the timers and manage them in a separate buffer. It's richer and I appreciated some of its documentation more. I haven't fully switched over to it yet. I'm still in exploratory mode. In fact, this is probably like... So I actually have a bunch more packages installed than I'm currently using. So I'm going to shrink this down a little bit just so that it doesn't line wrap.

43:57 Different stages of package use

Ben: But yeah, so I've got, I think about 140 packages locally cloned. I've got, as you can see in my init, about half of that actually installed. There are various phases. I've got a clone, but I don't have it in my init. Or I have it in my init, but there's another package that offers similar functionality. Or I'm all-in on this particular choice and I'm removing the other ones. It's a gradual kind of progression.

Sacha: Yeah, we're all auditioning packages to see if they fit in our workflow and all that stuff. I was curious also about your elfeed things. You have a few things related to elfeed. Actually, do you want to talk about the thing you just highlighted first?

Ben: No, we'll get back to it in a sec. I'm keeping an eye on the clock.

Sacha: But yeah, elfeed.

44:47 Elfeed

Sacha: Yeah, you've got a couple of interesting things in your elfeed setup, including picking a search from a bookmark or other shortcuts like that.

Ben: So I have discovered in my conversations with the new maintainers for elfeed that my elfeed habits are very deviant. So let me actually start off by going through... You can see that like the top of my elfeed list is kind of in one format and down at the bottom, the ones that are closer to present day are organized in a different way.

Sacha: You've got tags now.

Ben: So my feed list is, I mean, it started in Google Reader. It's kind of been forward ported since then. It's long.

Sacha: I love the comments.

Ben: But one of the consequences of having a long feed list is that I have an enormous elfeed database. And I use it for completely different purposes. So for example, I'm going to show off that little default search. I keep an eye on projects that have releases that aren't packaged by Debian, for example. So I've got this little ATS Mini. basically a small AM FM radio that happens to run on ESP32 and the firmware for this community developed and it's kind of interesting but like that's not packaged by Debian so I pay attention to or I subscribe to the release feed for that particular project. I do keep in keep an eye on the Linux kernel especially these days because The gallop of security vulnerabilities coming out of mythos analyses right now means that I have to pay more attention than usual to fresh updates. So generally I run Debian stable, but I do run kernels from backports and I want to know when those are available. MeshTastic. I was paying more attention to this a couple of weeks ago. I'm not going to reach that right now. But yeah, the local MeshTastic community in Toronto is plagued by a couple of griefers that make it a lot less fun. So I'm paying a bit less attention to that right now. But yeah, so like one of the bookmarks that I have is software currency. Another one is, for example, the YouTube channels that I subscribe to. Thank goodness for Elf YouTube. It is so nice to be able to get the transcripts for things directly in there.

Sacha: There's even a sponsor block integration so you can skip all the promotions and stuff.

Ben: Yeah, I mean, so again, my use of YouTube is also deviant in that I pretty much strictly subscribe to RSS feeds and they're downloaded onto the file server. So when a new recording comes out, it gets dropped there. I'll watch it. And then I've got a little widget that scans through my Kodi database for watched files. Once YouTube files show up in the watch list, they're automatically purged. And it means I just never see an ad. It's not just satisfying. I don't think that I would be able to pay attention if I was being constantly interrupted because of the way that my brain works. But yeah, so being able to quickly search for YouTube is one thing.

48:36 Spoilers

Ben: I do have articles that I've marked as spoilers for media that I haven't watched or read yet. Maybe I go to an extreme degree, but I'll try to avoid previews for new movies, for example. I do want to actually go back to them later on. Marking articles as having spoilers that I want to revisit later on is an easy way of not having to worry about it anymore. For a while, back in the days when I was paying more attention to... Enter the Dragon was the sequel to... What was that TV show? George R.R. Martin... Seven seasons and it went badly off the rails in season six.

Sacha: Game of Thrones.

Ben: Thank you. So when I was watching that for a while, several of the sites that I was reading would have individual episode updates. I really appreciated having a list of Elfeed keywords that I could automatically apply those tags to. I wouldn't even see the headlines because it was problematic enough. I've become less...

Sacha: Nice.

Ben: I've been putting less effort into maintaining that now, but the infrastructure is still there, and I can lean on it if I need to.

49:53 Comparing different news sources

Ben: One of the things that I don't have set up right now is a quick search for the municipal topics that I cover. I tend to subscribe to a lot of news because I found that, for example, it's interesting to see how the Toronto Star covers stuff differently from other local newspapers. It's useful to be able to quickly pull up the five or six publications that cover news in the same way and then look through the annotations for them or add the annotations myself. I can see that this particular story was covered by this journalist in this publication in this way, and then it lets me cross-reference so that I can pay attention to topics that are under-covered or publications that habitually leave out particular aspects of news stories. It lets me pay more attention to the trends of publications as well as to the stories that they're covering. The consequence of that is that my Elfeed database is 4.5 gigs. It's common for me... I don't know if that actually shows. It's common for me to have like 65,000 articles in like the six month horizon for the default Elfeed searches. That means that searches and redraws are expensive, even on a relatively performant machine. You've probably seen some of the workarounds that I've got. This little bookmark selector is one of those workarounds. Elfeed's interactive search: super, super useful. But if you're trying to do it like this... Actually, it's not so bad.

Sacha: I love this. When you see someone using Elfeed for 65,000 items, you get a sense of what it can be used for when you're really stressing it.

Ben: And the organization of the bookmarks that I have means that I do have one river of news of all of the things that I want to pay attention to. But it's seven or eight pretty divergent topics with not a lot of overlap. It's neat to be able to think of Elfeed as the thing where news information comes in. The individual bookmarks are the topics that are grouped together that I actually care about and want to read about in concert with each other. If I specifically narrow it down to just Emacs stuff, one of the things that I can easily do is add a bookmark for that search. If I name it... Now that I've got that bookmark saved...

Sacha: And then it's like, bookmark annotation.

Ben: Right. It ends up in my dot file as a git commit.

53:13 Bookmark naming conventions

Ben: Now that that bookmark exists, simply because of the naming (elfeed-search-...), now it shows up in completion.

Sacha: Precisely this sort of stuff. I am under-utilizing bookmarks, I think.

53:24 Naming conventions simplify building new workflows

Sacha: I love this idea of using bookmarks with a naming convention and then writing Emacs Lisp to take advantage of that naming convention to make that easy to jump to, easy to use in other things.

Ben: Yeah, it means I don't really have... When I notice that there's a thing I don't have, it diminishes the activation energy for building a new workflow. It means that I don't have to put a lot of thought into it. I can quickly do it. If it turns out to not be useful, I can quickly get rid of it.

Sacha: Very cool.

53:50 elfeed-curate for annotations

Sacha: I had one more thing that I wanted to ask you about elfeed that I want to squeeze in, in the five minutes that I have before the kiddo comes out for lunch break. This elfeed-curate that you're using, this is the first time I've come across it in the config. Are you sharing your notes or your selections with other people, or just for yourself?

Ben: No. It's just for myself. What I'm trying to replicate is, back in Google Reader days, I really appreciated how when you added an annotation to an article that you were reading, by default, that annotation would be viewable by other people in your social graph. That was super interesting. Sometimes you could also add personal-only annotations. Actually, I don't think that's the keyword that it uses. I think it’s just +ann.

Sacha: Also, because you have an Emacs keyword on it, so I don't know whether you have any annotated Emacs ones.

Ben: Yeah. Well, I mean, generally, if I've added an annotation, it will be. So, for example, here. Right? Super useful. Well, super useful for me, anyhow. If I find that there's an annotation that is more... This is inflammatory. It doesn't need to go out on the web.

Sacha: Sorry, did you need me to kill the stream? I have a 10-second window.

Ben: No, it's all good. I'm not worried about sharing this, but it's not something I've posted. What the nice thing is, is that if it is something that I want to share, it's really, really easy to just drop this into Mastodon mode.

Sacha: Very cool.

Ben: That's one of the ways that I use it. Because the annotations are just Org Mode files, you can add links to other things and it becomes just as useful as anything else.

55:46 mytoots archives Mastodon toots

Sacha: You're saying this can flow into Mastodon and from there, once you toot it... I think you're using mytoots that you mentioned in your config for archiving it? Or searching, yeah, okay. Oh, except it's currently not working.

Ben: Yeah, I don't have it loaded right now. So mytoots, it just loads the backup of your export archive. So it loads the... What's the most recent one? So yeah, it was your outbox JSON file, which is the most recent one here. I've got an Org Mode reminder to download it roughly quarterly. My outbox is about 100 megs right now. Compared to 4.5 gigs for elfeed, it's not so big. That's not going to redraw properly. I was just going to show it. My resident Emacs memory size right now is about like five or six gigs. It's a little bit embarrassing. By comparison, 100 megs of JSON in RAM is not so bad, but having an instant search for everything that you posted and being able to bounce back from your local archive to the conversation thread that's live and see anything new that comes in... Again, it lets me exercise that outboard brain kind of idea. So yeah, mytoots is super useful.

Sacha: I like it a lot.

57:06 Mentoring offer

Sacha: The last thing that I want to ask before the kiddo (because I have two minutes) is that you have a mentoring offer pinned in your Mastodon, too. Have people taken you up on it, especially if they've taken you up on Emacs? Is that ongoing or forgotten about or whatever?

Ben: Not forgotten about. Very much real. Still open. I haven't refreshed that offer recently, but it's still pinned for a reason. I think maybe a dozen or so folks have asked for that. 9 or 10 success stories, I think. Nobody's asked for Emacs tutorialship yet. That's fine. Again, I love Emacs. I use it. I don't often recommend it. But if anybody was curious about that, I would be very open to the idea.

Sacha: All right, so if people want to also develop a very interesting elfeed setup, they know who to talk to.

Ben: Please, I would love that conversation.

Sacha: Thank you so much. Yes, go ahead.

58:02 A local instance of public-inbox can let you use Gnus to read mailing lists quickly

Ben: Oh yeah, there's just one last thing I want to mention, and I realize we're right up against time. I use Gnus. I use mu4e for email, but I use Gnus for reading mailing lists. I just wanted to strongly recommend to anybody who is thinking about it... This is amazing. You gotta do this. public-inbox lets you keep a complete local archive of the entire mailing list. Searches are instant. Tracking threads is instant. Check it out. It's fantastic.

Sacha: That's great because Emacs-devel has a gazillion threads. How do you even keep track of all this stuff? But if you've got Gnus and if you've got this set up, then you're no longer dependent on the good graces of Gmane being around as an NNTP to mailing list gateway. @JonKishore11 wants to know if you have a YouTube channel. I'm guessing you don't yet.

Ben: I don't really like my face very much.

Sacha: Ping Ben on Mastodon and ask about this mentoring thing and then share your notes so we can all learn from it. Thank you so much for today. I look forward to chatting with you more through toots. What is the verb, you know, in the fediverse? All right. Thank you so much.

Sacha:

You can e-mail me at sacha@sachachua.com.

Here’s a niche problem: When viewing iPhone-captured photos in org-mode on Linux, they always appear in landscape orientation, even if you took them in portrait.

The reason is that the sensor of the camera on the phone is physically embedded in landscape mode, so all photos are in landscape mode; when you hold the phone in portrait mode (which is how you hold it most of the time), the phone detects that and implements a fix in the EXIF data file. Essentially, a software fix to a hardware design issue.

Since most photos I take are usually in portrait orientation, it means I need to twist my neck and view images at a 90-degree angle when I look at my Journelly entries.

The source of the problem seems to stem from how org-mode interprets EXIF data in the photo: it doesn’t. It relies on other parts of Emacs, which in turn rely on parts of the OS, to do the job. On Linux (at least on Kubuntu, which is what I use these days), those parts don’t handle EXIF orientation information. Why and how, I am not sure, it’s more digging than I have the time for right now… but anyway - there’s a simple fix.

Auto-orient, which is part of ImageMagick’s mogrify tool. And if you use Emacs on Linux, good chance it’s already installed:

This operator reads and resets the EXIF image profile setting ‘Orientation’ and then performs the appropriate 90 degree rotation on the image to orient the image, for correct viewing.

To execute on an image file: mogrify -auto-orient <file>.

And because I use Emacs, of course there’s a dwim-shell-command solution:

    (defun jtr/dwim-image-auto-orient ()
      "Auto-orient images based on EXIF data using mogrify."
      (interactive)
      (dwim-shell-command-on-marked-files
       "Auto-orient images"
       "mogrify -auto-orient '<<f>>'"
       :utils "mogrify"
       :silent-success t))

That last part,:silent-success, closes the empty buffer that pops up after successful execution, as mogrify doesn’t really produce an output window. So, it will just bring us back to Dired.

Two years ago I wrote a super simple todo package for Emacs to see whether I could get over my tendency to 1) procrastinate a lot and 2) being annoyed at my tendency to procrastinate.

Reader, you won’t believe the answer: Yes and no. Or rather, no and yes.

That is, I still procrastinate a lot (but less than before), but I’m way less annoyed about it.

As you can clearly see from the Emacs mode line above, I’ve got 27 “new” things on the todo list, 4 things that are “in progress” and… tada! 616 things that have been done!

It cannot be! That’s about one thing per day! (Although it’s more like no things most days and then eight things on a random day.)

I’ve had a look at other todo systems, but like I said two years ago, they seem to be specifically made to enable further procrastination: You can tinker endlessly with priorities, deadlines and arranging things in hierarchies. So you can spend an hour working on your todo list and then feel you’ve really made some progress. Which is a total lie, of course.

And open sores todo lists encourage further meta-tweaking — altering the todo software itself, so that you can add even more features. I’m proud to say that after starting to use it two years ago, I haven’t touched the anddo code even once! Behold the Microsoft Github repo!

So it’s just a list of tasks, and the ones that are new or in progress are shown. You can edit them and add notes, and you can change status, but that’s it. No dates, no priorities, no nothing. Just do it.

This system has really made me actually take care of a lot of annoyances and stuff, but even more importantly: Instead of looking at the lamp that’s sitting on the hall table every day and going “oh yeah, I should hang that on the wall somewhere; I must remember that”, I just put it on the todo list… and then my brain stops doing that every time I see the lamp on the hall table.

The system works!

(And then I might even hang it on the wall one day when I’m in the mood to do something, and I pull up the todo list… I might.)

I sort of… postpone the procrastination.

Anyway. That’s the life hack.

The text editor I'd used for 20 years on an MS-DOS platform would change the shape of the cursor to distinguish between insert mode and overwrite mode. A filled rectangle (or box, in Emacs terms) indicated overwrite mode; an underscore (hbar), insert mode. It's a nice way to make overwrite mode obvious.

The video starts out with Emacs in Insert Mode. Then Overwrite Mode is activated, which changes cursor-type from hbar to box. The word "Overwrite" replaces "Insert" to demonstrate the effect.

Incidentally, you might enjoy listening to some sound while playing back the video. One of my favorites is "Forest Voice" from https://mynoise.net, by Dr. Stéphane Pigeon.

Anyway, here's a function to implement that behavior in Emacs:

(defun zeit-change-cursor-shape ()
  "Set cursor shape depending on overwrite mode.
When overwrite-mode is nil (off), set cursor-type to hbar.
Otherwise, set it to box."
  (interactive)
  (if (not overwrite-mode)
      (setq cursor-type 'hbar)
    (setq cursor-type 'box)))

(add-hook 'overwrite-mode-hook 'zeit-change-cursor-shape)

2026-06-02 Add add-hook  as suggested by @Howitzer105mm@pdx.social

2026-06-02 Move hook outside function

This is an excellent little tweak to org-mode deadlines. I added it and it makes them look just a bit nicer.

Years ago, when I learned from mbork how to get my own copy of Webster’s 1923 dictionary my dictionary use was vastly improved. If you don’t know why having Webster’s 1923 is a big thing, here’s my original post on it from 2015.

For Emacs users, the package you need is quick-sdcv.el, an update of the original sdcv package. Actually, quick-sdcv useful for a lot more than just Webster. You can even use it to access the Oxford English Dictionary from within Emacs. Obviously, there’s a lot to like.

The point of this post is to pass on the announcement that sdcv-quick has been updated. If you do any writing at all you need sdcv and Webster’s 1923. Having the OED is a bonus. Happily, it’s easy to have it all in Emacs with sdcv.

Emacs

Update

Things have slowed on the Emacs front. I am not tweaking the init file every day and trying to get things just right. It is a good state to be in. There are no pain-points in the use of Emacs which has been bugging me and after all this time, it is a relief. Don’t get me wrong. I love tweaking. I love discovering new packages and trying them out. That is fun for me. But the basic configuration is stable, I understand it, I am trying to incorporate it into my muscle memory and things are peaceful.

That doesn’t mean I haven’t discovered a few nice things from the last time I wrote about Emacs. Here we go.

anddo.el

I found A Super Simple Todo Package For Emacs – Random Thoughts. The GitHub repo is larsmagne/anddo.el: A very simple todo package for Emacs.

This is a simple todo package and it is what I need for simple list-based task management. It’s simplicity is what makes this useful.

My setup:

;; anddo
(add-to-list 'load-path "~/.emacs.d/elisp/anddo.el")
(use-package anddo
  :ensure nil)

You run the anddo command and then you can manage your task list with anddo. It is an useful addition, which is well implemented. I love it.

;; Bound to M-o 8
"8" '(anddo :which-key "anddo") 

Substitute

I have been trying out multiple-cursors and for some reason I never seem to use it. I have tried to make the keyboard commands easier. I have included it in the general.el setup, but at the end of it, I never seem to use it.

Time for a different solution: Substitute (substitute.el) | Protesilaos Stavrou. Let’s see if this gets more use.

My config for substitute (directly copied from Prot’s suggestions):

(use-package substitute
  :ensure t
  :config
  ;; Set this to nil if you do not like visual feedback on the matching
  ;; target.  Default is t.
  ;; (setq substitute-highlight nil)

  ;; Set this to t if you want to always treat the letter casing
  ;; literally.  Otherwise each command accepts a `C-u' prefix
  ;; argument to do this on-demand.
  (setq substitute-fixed-letter-case t)

  ;; If you want a message reporting the matches that changed in the
  ;; given context.  We don't do it by default.
  (add-hook 'substitute-post-replace-functions #'substitute-report-operation)

  ;; Use C-c s as a prefix for all Substitute commands.
  (define-key global-map (kbd "C-c s") #'substitute-prefix-map)
(define-key substitute-prefix-map (kbd "b") #'substitute-target-in-buffer)
(define-key substitute-prefix-map (kbd "d") #'substitute-target-in-defun)
(define-key substitute-prefix-map (kbd "r") #'substitute-target-above-point)
(define-key substitute-prefix-map (kbd "s") #'substitute-target-below-point))
#+end_src

And a general.el keybinding:

;; Bound to M-o 3
"3" '(substitute-prefix-map :which-key "substitute")

Code Folding

Emacs: The Definitive Guide to Code Folding | James Cherti is an article I learned from.

I use jamescherti/kirigami.el: kirigami.el, a unified method to fold and unfold text in Emacs: outline, outline-indent, org-mode, markdown-mode, gfm-mode, vdiff, hideshow, fold-this, ts-fold, treesit-fold, vimish-fold… for my folding needs. It is fantastic.

Sunk Cost

The Emacs Lock-In Effect or the Emacs Sunk Cost Fallacy. Was an interesting read.

Emacs and the Sunk Cost Fallacy. Elaborated on the notion and came up with the assertion that this is not sunk cost fallacy at all. It is sunk cost. Sunk cost fallacy is a different thing altogether. The key statement to me was “A person commits the sunk cost fallacy when deciding to continue a project by considering the irrecoverable investment rather than the future utility of the project.”

I loved this analysis but let me move away from the description of this phenomenon and explain my reality when it comes to this feeling.

I use Emacs and Org-mode for my writing. For the blog I use Markdown. All of my writing gets done in Emacs. I get distracted by the new shiny once in a while. I tell myself that I am curious about new solutions because it gives me things to write about for the blog. I am not sure that I buy that rationale. Yes, it does give me new things to write about. Sometimes the products I write about become a critical part of the workflow but most of the time I go back to whatever solution I was using previously. For the last couple of years, the most used application on my computer has been Emacs. I write. Every day. In text files. Emacs is the center of all of that activity. I try out every text editor that gets released or that I come across. Look at it for a while and return to Emacs. Why?

1. I am familiar with Emacs. If you break down the cognitive load of writing into two components: the content you are writing and the load coming from the act of dealing with the application you are writing in, the Emacs load is minimal. I know the program enough to not have to worry about it. Low cognitive load on that front. That is the ideal state and new applications don’t reach that state without considerable effort.
2. The nature of Emacs. If I don’t like how Emacs does something, I know enough to be able to hack a solution together which makes Emacs behave the way I want it to. The ability to customize Emacs is one of the killer features which keeps me using it. I must admit that I am a novice in this regard. I am learning and trying to get better.
3. I have spent an ungodly number of hours figuring out how to use Emacs. That knowledge is paying off in the increased comfort I have with the program. Picking up another text editor and learning how to use it is a chore which I don’t need to do. It is not a fear of throwing away all the time I invested in Emacs, it is the ridiculousness of learning how to use a new program when I am perfectly happy being in Emacs. In other words, I don’t see the upside.

I am not doing a cost-benefit analysis of what it would mean to switch from Emacs to something else. Why would I? I am happy here.

I was talking to a non-technical new Mac user who asked for advice on text editors and knowledge management. I told him to look at some alternatives, Bear, Ulysses, Scrivener, iA Writer, Obsidian, VSCodium and BBEdit. Pick one and dive into it. Delete all the others from the machine and use that one program for the next two years. Two years of regular use is sufficient to understand BBEdit, VSCodium and Scrivener. Obsidian would probably take six months. The rest of the programs need a week of use. But stick to that solution. Use it all the time. The maxim is “The best editor is the one you know.” The ideal state is when the cognitive load of using the program is near zero.

If I was talking to a minimally technical Mac user, I would suggest they use Emacs. No question. Start the journey today.

That is my take on the sunk-cost fallacy and Emacs usage.

Must-have Emacs Packages for Efficient Software Development and Text Editing | James Cherti

This was a nice list of packages for the new and not so new Emacs user.

Emacs Bankruptcy

An opinionated and reasoned take on Rejecting Emacs Bankruptcy | Irreal.

I find myself agreeing with the author. I did go through a switch from using babel and Org-mode to manage my config file to using a plain elisp file several months ago. That was the main change. I can’t see myself throwing away a couple of years work to start from scratch, that sounds crazy to me. I do make changes and add/delete things depending on my usage. That is a process which might go on for ever. That is okay. It means that I am learning new things or finding different ways to do the same things. I try out something new, if it works, I keep it. If it doesn’t I go back to what I was using before or come up with a different way of doing it. That is what makes the journey interesting and involved.

That is all I have for today.

macosxguru at the gmail thingie.

TL;DR

If you use both Scrim and Emacs on macOS, you can “Open in Emacs” a file or directory from Finder via the “Quick Actions” context menu. This is implemented as a macOS Shortcut, shared as an iCloud link:

“Open in Emacs” Shortcut iCloud Link

Motivation

I find macOS drag-and-drop operations from Finder to Emacs (in particular, the NS variant) to be frustratingly inconsistent.

• Dragging a file or folder from Finder to a non-Dired buffer will visit it.
  • Not always! This behavior can be mode-specific.
• Dragging a file or folder from Finder to a Dired buffer will copy it.
• Dragging a file or folder from Finder to the Emacs icon in the Dock will visit it in a new frame.

Add to that, drag-and-drop isn’t graceful with a long traversal path on a large screen.

Ultimately, what I want is a single consistent action to “Open in Emacs” a file or directory from Finder. This post describes a solution for achieving this using the Scrim and macOS Shortcuts apps.

Background

Scrim

Scrim is an Org protocol proxy app that I had published on the App Store last year. Implementing Scrim was largely an exercise in reverse-engineering emacsclient to be a macOS app. This is because macOS apps these days (macOS 10.14+) are packaged to execute as a hardened runtime (aka “sandboxed”). Among the many things a hardened runtime restricts is the ability for an app to exec another program outside of its sandbox (like emacsclient).

In lieu of that restriction, macOS provides different APIs to let apps work with other apps, among them Services (more below), Intents (a whole different topic worthy of another post), and custom URL schemes.

A custom URL scheme is what Scrim provides to allow other apps to do emacsclient-like things like opening a file. By design, Scrim does not surface all the capabilities of emacsclient such as arbitrary Elisp execution. The custom URL scheme itself is scrim://.

Currently the scrim:// URL scheme supports the following two actions:

1. Visit a file or directory (e.g. scrim://open?file=~/.profile)
2. Open an Info node (e.g. scrim://info?node=(eshell) Top)

For this post, we will concern ourselves with (1) visiting (opening) a file or directory.

Note that on a system where a custom URL scheme is installed, any app on that system can open said custom URL scheme.

Services

The macOS Services API allows an application to access the functionality of another.

Apple uses this API to provide tools to help orchestrate workflows between different applications, namely AppleScript, Automator, and Shortcuts. Note that as of this writing, AppleScript and Automator are in maintenance mode, and Shortcuts is intended to supersede Automator. Once a workflow is defined, it is usually accessed via a context menu sub-menu labeled “Quick Actions” or “Services”.

“Open in Emacs” Shortcut

With the above background out of the way, let's turn our attention to the Shortcut itself.

The shortcut invokes a Python script which forms the scrim://open?file custom URL and then opens it with the open command line utility.

1
2
3
4
5
6
7

import sys
from subprocess import call
from urllib.parse import quote

buf = "scrim://open?file={0}".format(quote(sys.argv[1]))
cmdList = ['open', buf]
call(cmdList)

This shortcut can be installed via iCloud link: “Open in Emacs” Shortcut iCloud Link.

When installed, the menu item "Open in Emacs" will appear in the "Quick Actions" sub-menu when the context menu is raised on an Finder item.

“scrim link” Shortcut

What if you want just the Scrim URL to open a file or directory instead? The shortcut "scrim link" shown above provides that, putting the URL into the system clipboard to paste into another native macOS app like Notes or TextEdit. Such apps that recognize custom URL schemes will treat the URL as a “live” link.

This shortcut is available at “scrim link” Shortcut iCloud Link.

Closing Thoughts

While the behavior of "Open in Emacs" seems modest, a lot of things need to happen under the hood to orchestrate the different apps required to make it happen on macOS. But taking a step back, I'd observe that this is not unique to just macOS alone. Other contemporary operating systems are following suit as seen with Snap (Ubuntu) and Flatpak for Linux, and UWP for Windows. Such isolating practices by OS vendors are not going away.

Running counter to this is the spate of interest in orchestrating apps and/or services together using AI tools, whose approach so far is to bypass all hardened runtime boundaries.

Then there is comparison to the Emacs ecosystem, where orchestration of apps (or rather modes) is routinely done via Elisp. By implementation circumstance there are effectively no concerns for security boundaries within the internals of Emacs.

There's a lot of ground to ruminate on, in particular software malleability and orchestration, which I intend to do with future posts on this blog.

This is an edited transcript of my chat with Matei Candea, an anthropologist who is curious about the Emacs community and AI. Sharing it here with permission so that it becomes a thing I can refer to and in case it sparks further conversations. AI is a bit of a contentious topic, so I hope people will be patient and kind as we figure things out!

Related links:

• AI and scholarship: a manifesto | University of Cambridge
• Emacs and Vim in the Age of AI | (think)
• The Emacsification of Software — Quarrelsome (HN)
• The Lisp Curse
• EmacsConf
• EmacsWiki: Usergroups
• Emacs calendar