Planet Emacslife

Charlie Holland has a very nice contribution to June’s Emacs Carnival about underappreciated Emacs builtins. His post is about the Emacs help system and how you can use it to learn everything about Emacs. It’s a commonplace to say that Emacs is self-documenting but that’s little more than a slogan. Holland takes a long look at what that actually means.

He begins by noting that the help system is self-recursive is the sense that you can ask the help system about the help system. You simply call the help-for-help command intuitively bound to Ctrl+h Ctrl+h. If you’ve never tried it, try it now. It gives you a nice listing of every help command.

Once you invoke help for a certain command or variable, you get a buffer containing a description of the command or variable as well as links to related commands/variables and the source code of the command so you can see exactly what it does and how it does it. You can discover what command a shortcut calls or what the shortcut for a command is with a simple help call.

There are a bunch of other aspects to the help system. You can, for example, get a listing of what your last commands were, complete information about the character at point, the current value of a variable, the current mode, and lots more.

For discovery, there are the apropos command and its siblings to help you find what you’re looking for even if you have no idea of its name. You merely need to have a general description of what it does. Fuzzy completion on command invocation (Meta+x) helps you find the right command even if you have only a vague idea of its name.

Hoplland’s post is long and has a lot of information but it’s one that every Emacs n00b—or more experienced user, for that matter—should read. In Holland’s terminology, it’s the first node in the Emacs knowledge graph.

Karthik Chikmagalur recently published another of his excellent "Even More Batteries Included with Emacs" posts, digging into lesser-known features that already ship with Emacs today. I wanted to write its mirror image. His post covers the batteries already in the box. Mine covers the ones arriving in Emacs 31.

Emacs 31 isn't out yet, but I've been building it from both emacs-31 branch and master and daily driving it for months. Every time something new and useful lands, I fold it into Emacs Solo, my no-external-packages config, and mark it with a small ; EMACS-31 comment so I remember to revisit it once the release is official.

This post walks those breadcrumbs. Every change below is one I'm touching in my config right now, with a note on what it does and why I keep it. None of it requires a package. It's all either on master already or close behind.

One disclaimer: Emacs 31 is still in development (actually in pre-release phase), so names and defaults can shift before final release. Everything below is what I'm running as of mid-2026. If you're not building from emacs-31 branch or master, treat this as a preview of what's coming.

Tree-sitter that just works

If I had to pick the single change I'm happiest about, it's this one. For years, getting a *-ts-mode going meant manually populating treesit-language-source-alist, calling treesit-install-language-grammar, and praying your toolchain was set up to compile the grammar. In Emacs 31 a lot of that ceremony goes away:

(treesit-auto-install-grammar 'always) ; EMACS-31
(treesit-enabled-modes t)              ; EMACS-31

treesit-enabled-modes set to t switches the major modes that have a tree-sitter variant over to it, and treesit-auto-install-grammar makes Emacs offer to fetch and build the grammar when it's missing instead of erroring out (more options are available like 'ask and 'ask-dir). This is the treesit-auto package experience, except now the core does the work.

The knock-on effect shows up all over my config. I used to keep lines like these around to teach Emacs where each grammar lives:

(add-to-list 'treesit-language-source-alist
			 '(typescript "https://github.com/tree-sitter/tree-sitter-typescript" "master" "typescript/src"))

In Emacs 31 the grammar sources for languages like TypeScript, TSX, Rust, TOML, YAML and Dockerfile live inside the modes themselves, so I've got a trail of ;; EMACS-31 this is now defined on mode code comments marking every block I get to delete once 31 ships. I'll take less config that does the same job any day.

One foot-gun worth flagging if you share your Emacs directory tree across machines of different architectures: the auto-installed grammars are not segregated by architecture. An x86_64 .so and an arm64 one land under the same name, so the binary built on one machine won't load on the other. Something to keep in mind.

There are many more tree-sitter improvements coming to Emacs. The developers have been working tirelessly on it, Yuan Fu, along with many others, have been continuously improving the tree-sitter experience across multiple areas. From better language support to usability and performance enhancements, tree-sitter in Emacs continues to evolve at a remarkable pace.

A built-in markdown-ts-mode (experimental)

Emacs 31 ships a markdown-ts-mode in the box, and this one is close to my heart. I started it. It grew out of a proposal I sent to emacs-devel back in early 2025, where the idea and the first version of the code were mine.

I'd be doing the mode a disservice if I let you think it's a solo effort. Stéphane Marks came along a bit later, rolled up his sleeves, and has since become a co-author of the mode. He's the energy behind much of what makes it nice to use today. He didn't send a patch or two and move on; he stayed, pushing the mode well past what I'd sketched out and sweating the details that turn "it works" into "it's a pleasure." Much of the polish I'm about to brag about is his. The mode is ours now, and it's better for it.

Watching an idea make the round trip from a mailing-list message to core code, and picking up a great collaborator on the way, is one of the most rewarding things about hanging around the Emacs community.

(use-package markdown-ts-mode
  :ensure nil
  :defer t)

It gives you more than colors, and these are the parts I want to show off:

✔️ Org users will feel at home. The keybindings and editing feel stay close to Org: navigating headings, folding sections, moving between structural elements. If your fingers know Org, you won't have to relearn Markdown.

✔️ Live, colored code blocks, even for non-tree-sitter languages. This is my favorite trick. A fenced code block gets fontified using the real major mode for that language, not dumped as flat monospace. It reaches Emacs' own internal modes too, so an ```elisp block lights up with true Emacs Lisp font-locking, and the other built-in modes do the same. You get proper syntax highlighting inside your code samples with no extra setup.

And it's not just colors: the code-block editing commands largely work too, so you can edit a fenced block with the target language's mode rather than fighting plain text. Completion inside blocks is still the rough spot, that infrastructure is wonderfully twisty and we haven't fully cracked it yet, so if you go poking, that's where the bugs hide.

✔️ Inline image viewing. Image links render in the buffer, so a Markdown doc with screenshots or diagrams reads like a document, not a wall of ![](path) noise.

And many more features discoverable and being developed.

Together these make it feel like a comfortable place to write and read Markdown inside Emacs, not a syntax highlighter bolted onto .md files.

One caveat I want to be upfront about: markdown-ts-mode is still experimental, and you have to opt into it. As the header of markdown-ts-mode.el notes, it isn't wired up to auto-mode-alist yet, so it won't take over .md files on its own. For now you pull in the library with M-x load-library RET markdown-ts-mode, then turn it on in a bufferf, or add it to auto-mode-alist yourself if you're feeling brave.

Stéphane and I are working to get it considered ready by the next Emacs release, and that's where you come in. If you try it and hit rough edges, or it works great, we want to hear about it. Send feedback to the bug list with M-x report-emacs-bug, or reach out to me and Stéphane directly. Real-world use is what moves a mode from "experimental" to "done", so don't be shy.

Many more screenshots here.

Eglot rendering docs with markdown-ts (also, still experimental)

Speaking of Markdown, Eglot in Emacs 31 can render LSP documentation using that same internal mode instead of falling back to plain text:

(eglot-documentation-renderer 'markdown-ts-view-mode) ;; EMACS-31
(eglot-code-action-indications nil)                   ;; EMACS-31

markdown-ts-view-mode gives you formatted hover docs without pulling in anything extra. The same experimental caveat applies here, since it leans on markdown-ts-mode, so treat it as something to opt into rather than a finished default. I also turn off eglot-code-action-indications. The new inline "you can do a code action here" hints are clever, but some language servers make them noisy, so I keep them off.

There's also some churn here: eglot-events-buffer-size is on its way out in favor of eglot-events-buffer-config, so I've left a ;; EMACS-31 -- do we still need it? note on the old variable to clean up later.

eldoc at point

A small one I'm fond of:

(eldoc-help-at-pt t) ;; EMACS-31

With this on, eldoc shows the help text for whatever sits under the cursor, without me invoking anything. Paired with eldoc-echo-area-prefer-doc-buffer, it makes wandering through unfamiliar code feel more guided.

Smarter, eager completion

The minibuffer and completion machinery picked up a few new toggles:

(completion-eager-update t)               ;; EMACS-31
(completion-eager-display 'auto)          ;; EMACS-31
(minibuffer-visible-completions 'up-down) ;; EMACS-31

completion-eager-update and completion-eager-display refresh the completion UI as you type instead of waiting for you to ask. If you don't run something like icomplete, setting eager display to t gives you a sharp out-of-the-box experience on its own. And minibuffer-visible-completions set to 'up-down lets you move through the visible candidates with the arrow keys, which feels natural at last.

icomplete got attention too, and this is another one I had a direct hand in. Emacs 31 includes the patch from bug#75784, which I proposed and worked on. It brings vertical in-buffer behavior and prefix indicators to icomplete. The side effect I like: a big compatibility block I'd been carrying in my config can finally go away:

(when (and (>= emacs-major-version 31)
		   (boundp 'icomplete-vertical-in-buffer-adjust-list))
  (setq icomplete-vertical-in-buffer-adjust-list t)
  (setq icomplete-vertical-render-prefix-indicator t))

Window layout gymnastics

This is a fun set of new commands for rearranging your window layout without manually splitting and killing windows:

("C-x w t"   . window-layout-transpose)        ; EMACS-31
("C-x w r"   . window-layout-rotate-clockwise) ; EMACS-31
("C-x w f h" . window-layout-flip-leftright)   ; EMACS-31
("C-x w f v" . window-layout-flip-topdown)     ; EMACS-31

Transpose swaps your horizontal and vertical arrangement, rotate spins the whole layout around, and the flip commands mirror it left-to-right or top-to-bottom. If you've ever built a three-window layout and then wished the editor pane were on the other side, these do the job and keep every buffer in place while they're at it.

A Speedbar that lives in a side window

Speedbar has been around forever, but in Emacs 31 it learned to live in a proper side window instead of a separate frame:

(speedbar-window-default-width 25) ;; EMACS-31
(speedbar-window-max-width 25)     ;; EMACS-31

;; bound to M-I in my config:
(speedbar-window) ;; EMACS-31

speedbar-window docks it to the side like a modern file tree. On a tiling setup or a single-monitor laptop, that beats the old floating-frame behavior by a mile. A width cap keeps it from fighting my other windows.

VC niceties

A few version-control improvements I've happily turned on:

(setopt
 vc-auto-revert-mode t                    ; EMACS-31
 vc-allow-rewriting-published-history t   ; EMACS-31
 vc-dir-auto-hide-up-to-date 'revert)     ; EMACS-31

vc-dir-auto-hide-up-to-date is the one I'm most pleased about. Refreshing a vc-dir buffer now hides the up-to-date files on its own, so I no longer need my g-key hack that called vc-dir-refresh followed by vc-dir-hide-up-to-date. Another block marked for deletion. vc-allow-rewriting-published-history nods to workflows like Jujutsu and force-pushing feature branches, where rewriting already-pushed history is a deliberate move.

Editable xref buffers

This one isn't a variable, it's a comment in my config reminding me to remove a custom hack:

;; EMACS-31 Remove this, since new emacs will come with 'e' for editing xref buffers.
;; Reference: https://debbugs.gnu.org/cgi/bugreport.cgi?bug=80616

I'm going to indulge myself and tell the longer version of this one, because I was part of it and it shows how features find their way into Emacs.

The itch was this. Both Dired and grep buffers have long had an "edit" workflow. In Dired you toggle into wdired-mode; in a grep buffer you press e for grep-edit-mode. Bulk renaming and bulk search-and-replace feel natural there. Xref buffers had no such thing. The only editing operation was r (xref-query-replace-in-results), which is regex-only and won't let you edit individual lines. I lean hard on project.el and xref for navigating and refactoring, and I kept catching myself re-running the same search with M-x grep to get an editable buffer. An annoying detour, since xref already held all the information needed.

So in March 2026 I sent a patch to bug-gnu-emacs proposing a small command, xref-export-to-grep, bound to E in *xref* buffers. It re-fetched the xref items, formatted them as file:line:content, and dropped them into a grep-mode buffer where you could press e and edit as usual. Nothing fancy. It bridged two things that already existed, and I'd carried it as a personal snippet for a while.

What happened next is the part I love about this community. Dmitry Gutov, who maintains xref, looked at it and pushed back on the UI of my approach. My command created a hop between buffers, and once you landed in the grep buffer you still had to know which key to press. He asked a sharper question than the one I'd answered: did I care about the grep export, or would it be better if xref buffers let you edit inline?

That reframing was right. I told him I had no attachment to the grep detour. Inline editing in the xref buffer itself, with multi-line edits across matches, would kill the whole roundtrip. A few days later he'd written and pushed xref-edit-mode. It drops the extra step and runs faster on large xref buffers. My original xref-export-to-grep could still go in as an optional command without a default binding, but the inline mode is the better answer and it's what I use now.

The thread didn't stop there. It spun off into a wider design chat with Juri Linkov about the *-edit-mode family (occur/grep/xref, which write each buffer normally) versus wdired's queue-everything-then-C-x C-s model, and whether a future "live" search UI might present results differently. For the record, here's the safety net I mentioned in that thread, a trick I picked up from Protesilaos that lets me hit d to diff a buffer against its file before saving during save-some-buffers:

(add-to-list 'save-some-buffers-action-alist
			 (list "d"
				   (lambda (buffer)
					 (diff-buffer-with-file (buffer-file-name buffer)))
				   "show diff between the buffer and its file"))

Back to the topic, the end result: Emacs 31 ships editable xref buffers, my config drops a homegrown workaround, and the feature that landed beats the one I proposed, because the maintainer asked the right question. Getting to play a small part in that loop is a big chunk of why I enjoy living on master. The full back-and-forth is public in bug#80616 if you're curious.

So, if you would like to try it. After C-x p g, grep for something like FontAwesomeIcon. Now e starts the edit mode, make your edits, C-c C-c to confirm.

ERC gets tidier

A couple of IRC improvements, since I live in ERC:

(erc-log-insert-log-on-open 'erc-log-new-target-buffer-p) ;; EMACS-31

This makes ERC insert prenvious logs only for newly opened target buffers, the behavior I want when rejoining channels. And one of my favorite small fixes: in Emacs 31 the scrolltobottom module no longer depends on erc-fill-wrap, so I can drop the conditional that used to add it by hand for older versions. Thank you to whoever untangled that.

The grab bag of quality-of-life knobs

And then there's the long tail of tiny improvements that don't each deserve a section but absolutely earn their place:

(delete-pair-push-mark t)                    ; EMACS-31: pushes a mark after
											 ; delete-pair so C-x C-x selects what was inside
(ibuffer-human-readable-size t)              ; EMACS-31: KB/MB instead of raw byte counts
(ielm-history-file-name ...)                 ; EMACS-31: IELM input history is finally persisted
(kill-region-dwim 'emacs-word)               ; EMACS-31: C-w with no region kills a word
(native-comp-async-on-battery-power nil)     ; EMACS-31: stop native-comp jobs on battery
(view-lossage-auto-refresh t)                ; EMACS-31: live-updating C-h l, great for teaching/debugging
(display-fill-column-indicator-warning nil)  ; EMACS-31
(dired-hide-details-hide-absolute-location t); EMACS-31: hide the absolute dir path in dired-hide-details-mode
(world-clock-sort-order "%FT%T")             ; EMACS-31: sort the world clock sanely
(zone-all-frames t)                          ; EMACS-31
(zone-all-windows-in-frame t)                ; EMACS-31
(uniquify-after-kill-buffer-flag t)          ; EMACS-31: renamed from the -p variant

A few of these are worth a sentence:

✔️ kill-region-dwim fixes a decades-old papercut. Set it to 'emacs-word and hitting C-w with no active region kills a word backwards instead of signalling an error. No more "the mark is not active" interruptions.

✔️ view-lossage-auto-refresh turns C-h l into a live view of your last keystrokes. When I'm screen-sharing or teaching, people can watch the keys I press in real time.

✔️ ielm-history-file-name lets my IELM scratch sessions survive a restart, the way comint and the shell already do.

✔️ native-comp-async-on-battery-power nil saves the laptop: no surprise fan spin-ups from background native compilation while I'm unplugged on a train.

✔️ tty-tip-mode brings tooltips to the terminal, a nice touch for those of us who run Emacs in -nw.

Honorable mention: term stops eating lines

This one gets no config line, because there's nothing to configure. A bug got fixed, and it makes me happier than it has any right to.

For a long time, term (and ansi-term) had a nasty habit of swallowing lines. Full-screen, cursor-addressing programs left the display garbled, with rows eaten or misplaced as the program redrew. That hit the exact programs you most want a real terminal for: htop, nethack, anything curses-based was close to unusable inside Emacs' terminal.

Emacs 31 fixes it. term redraws correctly now, and I can run htop to watch processes or fire up nethack for a "quick" break without the buffer turning into confetti. It sounds small, and it removes one of the last reasons I had to reach for an external terminal emulator.

Honorable mention 2: Modus 5 themes!

Thanks to Protesilaos, Emacs now ships with several modus themes:

✔️ modus-operandi-deuteranopia -- Deuteranopia-optimized theme with a white background.

✔️ modus-operandi -- Elegant, highly legible theme with a white background.

✔️ modus-operandi-tinted -- Elegant, highly legible theme with a light ochre background.

✔️ modus-operandi-tritanopia -- Tritanopia-optimized theme with a white background.

✔️ modus-vivendi-deuteranopia -- Deuteranopia-optimized theme with a black background.

✔️ modus-vivendi -- Elegant, highly legible theme with a black background.

✔️ modus-vivendi-tinted -- Elegant, highly legible theme with a night sky background.

✔️ modus-vivendi-tritanopia -- Tritanopia-optimized theme with a black background.

Why bother running master?

People ask why I daily drive an unreleased Emacs. Same reason I run a no-packages config: I want to know what's in the box, and the way to learn what's coming is to live in it. Most of these changes are small, yet they add up to an editor that needs less of my glue code each release. Watching my config get shorter as the core absorbs things I used to hand-roll is one of the quiet joys of being an Emacs user.

For the other side of this coin, the batteries already there waiting to be found, go read Karthik's post. It's a great companion to this one. And to see every snippet above in context, they're all in the Emacs Solo init.el, each marked with that small ; EMACS-31 breadcrumb.

See you when 31 ships, at which point I get to go delete a pile of code. Happy hacking.

Edit

2026-06-29: Updated treesit-auto-install-grammar to 'always.

2026-06-18: Thanks to Stéphane Marks for the careful read and corrections. He flagged the tree-sitter architecture foot-gun for shared config directories (now noted above), pointed out that markdown-ts-mode's code-block editing commands work and not just the highlighting, and caught that the VC variable is now vc-dir-auto-hide-up-to-date, not the name I'd written.

Over at Ray on Emacs, Raymond Zeitler writes about the Emacs Diary for the June Emacs Carnival. The June topic is underappreciated Emacs built-ins and for Zeitler that’s Emacs Diary. He was a little disconcerted at first by being offered a blank screen for each entry. He wondered where his previous material went but he came to appreciate the fresh start that that blank buffer gave him. He goes on to describes some of the functions and capabilities of Diary.

I recently started keeping a personal journal too and considered using Diary—it was, of course, going to be written in Emacs in any event—but decided to simply use Org mode instead. I have an Org capture template to start a new entry—just like Zeitler’s method—but I can, of course, just bring up the journal Org file directly to see or edit anything.

I’ve found that this works well for me. I don’t write in my journal everyday, just when something worth recording happens, so I don’t care about things like when the sun rose or set, what the temperature was on that day; just what happened that I felt was worth remembering. Of course, if I did care about such things it would be easy to arrange to add them.

Or I could just use Diary. That’s the beauty of Emacs: you can make it do pretty much whatever you need it to and very often what you need is already there.

When I adopted Emacs in July of 2000, I hunkered down to learn the keybindings. But after I learned the basics¹ I started to RTFM (C-h r), and I was instantly drawn to the Calendar/Diary² node, which I consider to be an underappreciated Emacs built-in, and, therefore, the topic of Emacs Carnival for June 2026.

Back then I mistook "diary" to mean a blank-page-confidant into which we write our thoughts, fears, ambitions or even just what we had for dinner last night. At that time I'd been writing in a journal for about 24 years (yes, since 1976, on and off), so my head swelled with ideas of using Emacs for a revamped computerized version. I imagined being able to forward-search-regexp in order to find, for example, that weird dream I wrote about in which I caught a toad that was hopping around the kitchen and then turned into a hot coal sizzling in my hand...

I used diary-block functions to date my entries and organize the content. I ended up making four such entries from 2003 to 2004. But each day following the entry, M-x diary would display a nearly blank buffer, showing only the day's date at the top followed by a line of equal signs and perhaps a holiday. Where did yesterday's entry go?! It was disconcerting that those words "vanished" into thin air magnetic film or silicon.

Today, however, I appreciate the simplicity of that approach -- a clean slate sans distractions. But back then I was accustomed to seeing a vast amount of my writing, which fed my ego.

But that's not all there is to appreciate. There are several functions that can be used for "an entry" in addition to diary-block, such as diary-anniversary, diary-cyclic, diary-float or even just a simple line that begins with a date and a brief note. This is not an all-inclusive list.

Every fancy diary buffer can show local time of sunrise and sunset; to do this, include diary-sunrise-sunset in the diary file. Include diary-lunar-phases to show one of the four phases of the moon when one is active on that day; the local time of that moon phase will be included.

What follows is an abbreviated and edited listing of my diary files. Note how I've structured diary into a hierarchy using include statements.

2026-06-17 02:25 GMT Important updates: First, you'll need to modify two hook variables in order for the include statements to work. Please see the help for Fancy Diary Display. I also "use the normal hook diary-list-entries-hook to sort each day's diary entries by their time of day," which is described at the top of that page. Second, specify the full path to the included files. I've modified the two include statements to add the "~/" path. This is needed only if you want to press TAB on the item in the Agenda in order to focus the diary entry.

The beauty of this is that these events will show up in Org Agenda at the appropriate times when org-agenda-include-diary is non-nil.

Four examples are shown below. Here are some things to note:

• The content that's derived from the diary file has "Diary" for value of CATEGORY.
• The Sunrise / Sunset lines are supposed to show the time of each occurance. However, the time for Sunrise isn't displayed; rather, it's indicated by its position on the time grid. The times for both the New Moon and the Solar Eclipse are indicated by the time grid, as well, and are expected to peak at 13:38 in my area. That's something to look faroward to!
• Sometimes I include links in my headings. In this case I can follow a link to the credit card website to pay the Visa card.
• Even a link in the dairy file will be rendered in the Agenda properly, as shown in the reference for Richard Stallman's birthday.

file listing: diary

#    -*- mode: diary -*-

#include "~/diary-anniversaries-property"
#include "~/diary-birthdays-friends"

%%(diary-sunrise-sunset)
%%(diary-lunar-phases)

%%(diary-remind '(diary-anniversary 3 16 1953) 14) [[https://html.duckduckgo.com/html/?q=Richard+Stallman+birthday][Richard Stallman's birthday]] in 14 days

%%(diary-block 6 21 2004 6 21 2004) The summer solstice.  I
always take time to observe the position of the sun on this
day, especially in the morning and evening.  Sunrise was at
5:16am and sunset will be at 8:29pm.  From today onward, the
days will be getting shorter.  At first it will be
imperceptible, but in September, it'll be quite noticeable.

file listing: diary-anniversaries-property

#    -*- mode: diary -*-
# Recurring Property events or records
%%(diary-remind '(diary-date 7 3 '(2023 2026 2029)) 30) Car Registration is due
%%(diary-anniversary 8 12 2022) Kitchen Cabinets Painted %d Years Ago

file listing: diary-birthdays-friends

#    -*- mode: diary -*-
# Birthdays of friends
%%(diary-anniversary 8 13) Bucky Thorndike Miller's Birthday (Does Dave still have his guitar amp?)
%%(diary-anniversary 2 13 1966) Ben's %d%s Birthday

Day-agenda (W11):
Tuesday    16 March 2027
  Diary:       7:03 ┄┄┄┄┄ Sunrise (EDT), sunset 18:58 (EDT) at Home (11:54 hrs daylight)
               8:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  BILLS:       9:00 ┄┄┄┄┄ Deadline:   TODO Visa Card LINK            :Bills::Credit:
              10:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              12:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              14:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              16:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              18:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              20:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  Diary:      Richard Stallman's birthday in 14 days

Day-agenda (W23):
Wednesday   3 June 2026
  Diary:       5:19 ┄┄┄┄┄ Sunrise (EDT), sunset 20:20 (EDT) at Home (15:00 hrs daylight)
               8:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              10:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              12:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              14:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              16:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              18:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              20:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  Diary:      Reminder: Only 30 days until Car Registration is due

Day-agenda (W33):
Wednesday  12 August 2026
  Diary:       5:58 ┄┄┄┄┄ Sunrise (EDT), sunset 19:54 (EDT) at Home (13:56 hrs daylight)
               8:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
               9:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              10:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              12:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  Diary:      13:38 ┄┄┄┄┄ New Moon (EDT) ** Solar Eclipse **
              14:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              16:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              18:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              20:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  Diary:      Kitchen Cabinets Painted 4 Years Ago

Day-agenda (W32):
Saturday   13 August 2022
  Diary:       5:59 ┄┄┄┄┄ Sunrise (EDT), sunset 19:53 (EDT) at Home (13:53 hrs daylight)
               8:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              10:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              12:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              14:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              16:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              18:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
              20:00 ┄┄┄┄┄ ┄┄┄┄┄┄┄┄┄┄┄┄┄┄┄
  Diary:      Bucky Thorndike Miller's Birthday (Does Dave still have his guitar amp?)

• column editing
• keystroke recording and playback
• regular expression search and replace
• undo
• support multiple files in multiple windows

The doric-themes are the minimalist counterpart of my modus-themes and ef-themes. They define few colours and exercise restraint in how they customise faces. This means that there rarely is a context that has red, green, yellow, blue, magenta, and cyan. Those are reserved for cases where colour-coding is needed. Whereas with my other themes colour is used with the dual intent of establish rhythm and order in addition to any colour-coding.

Because of this, it is difficult for me to test the relevant values. Each Doric theme defines entries in its palette like fg-red and bg-blue. So I decided to write a small snippet that shows text which uses those colours in context.

The idea is to create faces that get the appropriate :foreground and :background attributes with their proper values. Then write text in a buffer that displays each face.

(defconst test-doric-accents
  '( fg-red fg-green fg-yellow fg-blue fg-magenta fg-cyan
     bg-red bg-green bg-yellow bg-blue bg-magenta bg-cyan))

(dolist (accent test-doric-accents)
  (custom-declare-face
   (intern (format "test-doric-%s" accent))
   nil
   "Test."
   :group 'doric-themes))

(defun test-doric-set-accent-faces ()
  (doric-themes-with-colors
    (let* ((predicate (lambda (symbol) (string-prefix-p "bg" (symbol-name symbol))))
           (foregrounds (seq-remove predicate test-doric-accents))
           (backgrounds (seq-filter predicate test-doric-accents))
           (foreground-faces (mapcar
                              (lambda (accent)
                                `(,(intern (format "test-doric-%s" accent))
                                  ((t :foreground ,(symbol-value accent)))))
                              foregrounds))
           (background-faces (mapcar
                              (lambda (accent)
                                `(,(intern (format "test-doric-%s" accent))
                                  ((t :background ,(symbol-value accent) :foreground ,fg-main))))
                              backgrounds)))
      (apply #'custom-set-faces (append foreground-faces background-faces)))))

(add-hook 'doric-themes-after-load-theme-hook #'test-doric-set-accent-faces)

(defun test-doric-show-accents ()
  (interactive)
  (let ((buffer (get-buffer-create "*test-doric-themes-accents*")))
    (with-current-buffer buffer
      (erase-buffer)
      (dolist (accent test-doric-accents)
        ;; Pangram from my `show-font' package...
        (let* ((text "Protesilaos may find zesty owls and quiet jays vexing the black cat")
               (styled (propertize text 'face (intern (format "test-doric-%s" accent)))))
          (insert (format "%s\n" styled)))))
    (display-buffer buffer)))

Reload the theme for changes to take effect.

And, yes, I had the motivation to write this because I am developing new themes.

Doric themes sources

• Package name (GNU ELPA): doric-themes
• Sample pictures: https://protesilaos.com/emacs/doric-themes-pictures
• Git repository: https://github.com/protesilaos/doric-themes
• Backronym: Doric Only Really Intensifies Conservatively … themes.

In the last month or so, as I've mentioned a few times before, I've been trying to tidy up some of my older personal Emacs Lisp packages. I thought I'd updated all the ones I commonly use, but it turns out I hadn't. Somehow I'd missed become.el.

This is another one of those packages whose content started out as ad-hoc commands, added to the ~/.emacs that first started to emerge as I got to know Emacs on OS/2 and then GNU/Linux back in the mid-1990s. I think it was back in 2016¹, when I did a big revamp of my Emacs environment, that I moved all of those roughly-related commands out into their own file.

Honestly, I think I can dump most of them now. There's stuff in there for quickly and easily converting buffers between "DOS format" and "Unix format" (from back when I was still working a lot on Windows machines, and sometimes even in MS-DOS-based virtual machines, and often using the DJGPP-built version of Emacs).

One command I still use all the time is become-free-of-trailing-whitespace, because I have that set up as part of a before-save-hook:

(use-package become
  :ensure t
  :defer t
  :vc (:url "https://github.com/davep/become.el" :rev :newest)
  :commands become-free-of-trailing-whitespace
  :init
  (unless noninteractive
    (add-hook 'before-save-hook #'become-free-of-trailing-whitespace))
  :bind
  ("<f12> <tab>" . become-freshly-indented-no-tabs))

While I know that there are better ways of handling the trailing space issue these days, this is one I rolled for myself a couple of decades ago and it's yet to fail me. You can see just how dated it is from this:

(cl-flet ((is-sig-line ()
                       (save-excursion
                         (beginning-of-line)
                         (looking-at "^-- $")))
          (markdown-br-p ()
                         (save-excursion
                           (beginning-of-line)
                           (and (eq major-mode 'markdown-mode)
                                (looking-at "^.+[^ ]  $")))))
; ...body removed
)

If you know, you'll know why is-sig-line is there².

I do still use become-freshly-indented-no-tabs on occasion too, and have it bound to an easy-to-remember and obvious (to me) key.

And so, despite the fact that most of the content of become.el is probably obsolete at this point, despite the fact that there are probably far better and more idiomatic ways of doing these things these days... it's my little personal package that has grown with me in the 3 (and a bit) decades I've had Emacs under my fingertips. I'm going to keep it around just a little longer.

Marcin Borkowski (mbork) has a useful post on scrolling PDFs in the other window. He wants to use the familiar Ctrl+Meta+v and Ctrl+Meta+Shift+v shortcuts for pdf-tools. Sadly, these don’t work for scrolling PDFs but as mbork says, “… [I]t’s Emacs, so it shouldn’t be difficult…”. And, indeed, it isn’t.

His idea is simple. If the buffer in the other window isn’t a PDF, return nil. Otherwise simply call pdf-view-scroll-up-or-next-page or pdf-view-scroll-down-or-previous-page. Finally, he simply advises scroll-other-window and scroll-other-window-down to run his code first and skip the normal code unless his code returns nil. Take a look at his post for the code. As I said, it’s easy to understand.

The important takeaway from this, according to mbork, is how easy and understandable the solution is. The lesson, as it often is, is that if Emacs isn’t doing what you need, it’s usually pretty easy to make it do so.

Great news, everyone - CIDER 1.22 (“São Miguel”) is finally out!

And “finally” is the operative word here. This release took me way longer than I wanted it to, but that’s because I decided to stop kicking a few cans down the road and finally tackle some long-standing problems that had been bugging me for years:

• Session and connection management - the logic for figuring out which REPL a buffer is associated with had grown into something I could barely follow myself.
• The decoupling of nREPL from CIDER’s UI layer - a piece of technical debt so old it predates most of you reading this (the tracking issue, #1099, is from 2017).
• A full audit of the codebase and the documentation, hunting for inconsistencies, dead code, broken menu entries, and gaps in the docs.

None of this is the kind of work that makes for a flashy release announcement, but it’s exactly the kind of work that keeps a 14 year old project healthy. I genuinely think this is one of the most important CIDER releases in recent memory, even though most of the changes aren’t really user-visible.

Highlights

Picking a handful of items out of a very long changelog, here’s what I’d call the highlights:

• A huge editor responsiveness fix (#3933) - Clojure buffers no longer lag when there’s no REPL connected. The friendly-session matching used to scan the project classpath on every redisplay; now it does something far cheaper. If you’ve ever felt CIDER make your editing sluggish, this one’s for you.
• Default sessions (#3865) - cider-set-default-session lets you bypass sesman’s project-based dispatch and pin a REPL as the default. Handy for all those workflows that never quite fit the project model.
• nREPL is now decoupled from CIDER’s UI (#3892) - the transport layer no longer reaches into CIDER-specific handlers and UI strings. This finally closes #1099 and opens the door for other tools to build on our nREPL client.
• Faster connection completions (#3888) - repeated cider-connect completions no longer re-spawn a round of ps/lsof subprocesses every single time.
• A massive discoverability pass on menus and keybindings - menus across the inspector, REPL history, log, spec browser, and more now actually expose the commands they were missing (often a dozen+ per mode), and C-h m now lists the active bindings for several modes. A lot of functionality that was technically there but practically invisible is now front and center.
• cider-repl-history-doctor (#3921) - a new command that walks your REPL history, finds entries with unbalanced parens, and helps you clean them up. Born out of a real bug report about history rendering breaking.
• Support for let-go (#3926) - a Clojure dialect implemented in Go is now recognized as a known nREPL runtime.
• Better remote (TRAMP) jack-in and connect (#3885, #3886, #3887) - endpoint detection, command resolution, and SSH tunneling all behave correctly against remote hosts now.
• Plenty of nREPL robustness fixes - plugged several request-id leaks, bounded the completed-requests table, and made a misbehaving response handler no longer able to drop later responses on the floor.
• Bumped the injected nREPL to 1.7.0 and cider-nrepl to 0.59.0.

The full list is much longer - check out the changelog if you want the gory details.

A fun little detour: Port and Neat

While I was doing the nREPL decoupling work, I got curious and started experimenting with adding support for prepl (Clojure’s built-in socket REPL) as an alternative to nREPL. I even put together a prototype (cider#3899). It sort of worked, but it also reaffirmed my belief that prepl and nREPL are different enough that bolting prepl onto CIDER would mean papering over its limitations in dozens of subtle places. So instead of forcing it, that little experiment grew into two brand new projects of mine:

• Port - a minimalist prepl client for Emacs.
• Neat - a tiny, deliberately language-agnostic nREPL client.

Both have write-ups of their own, so I won’t repeat the details here. I’m pretty excited about where they might lead - a great example of how digging into old technical debt can spark entirely new ideas.

Epilogue

This release is dedicated to São Miguel, the stunningly beautiful main island of the Azores archipelago.¹ I got a lot of my recent inspiration for CIDER there, and naming the release after it felt right.

As always, none of this happens in a vacuum. A huge thank you to Alex Yakushev for his continued work on the inspector - it keeps getting better and better. And of course a massive shoutout to Clojurists Together and to all the other contributors and backers of my open-source work. You’re the reason CIDER and friends keep moving forward.

That’s all I have for you today. I hope you’ll enjoy using CIDER 1.22 as much as I enjoyed (eventually) shipping it. Keep hacking!

The simplification of my mode line is sticking, in that I like how it's turned out and I find it more useful to have it this simple. But I did notice something was missing: I'm a pretty constant but pretty casual user of projectile. I know it's a package that offers a wealth of tools, yet mostly I just use it as a project bookmark system. For this, though, it works well.

Given this, having a quick and easy way to check that I'm in the project I think I'm in is a good idea. While I also have neotree open all the time, which gives a fairly obvious clue, my eyes keep flitting down to the mode line.

The change I made the other day, deliberately, left the project off. I think this was a simplification too far. So now it's back.

The core of my mode line configuration now looks like this:

(setq mood-line-format
      (mood-line-defformat
       :left
       ((or
         (mood-line-segment-buffer-status)
         (propertize
          (mood-line--get-glyph :buffer-modified)
          'face 'my/mood-line-good-status))
        " "
        (mood-line-segment-buffer-name)
        (my/mood-line-segment-project)
        " "
        (mood-line-segment-major-mode))
       :right
       ((my/mood-line-segment-vc)
        " "
        (propertize
         (mood-line-segment-cursor-position)
         'face 'my/mood-line-cursor-position))))

A little busier than it started out, but still pretty clean. I do keep wondering about the cursor position. In most buffers I have line numbers showing to the left anyway, and it's rare (but not unknown) that I need to know what column I'm in. I'm very tempted to remove the cursor position altogether, then the right-hand side would just be the vc information, at which point it might make sense to also move the project name over to the right, given that the project and the repository information generally go hand-in-hand.

I'll stick with this for now, but I can see this happening soon.

Lots of discussion around Karthik's latest blog post Even More Batteries Included with Emacs (Reddit, HN, lobste.rs). Check it out!

• Emacs updates:
  • Emacs 31.0.90 pretest packages for Fedora (Reddit)
  • Emacs 31.0.90 pretest packages for Android, via F-Droid (Reddit)
• Upcoming events (iCal file, Org):
  • 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
  • OrgDevMeetup https://bbb.emacsverse.org/rooms/orgdevmeetup Sat Jun 20 0900 America/Vancouver - 1100 America/Chicago - 1200 America/Toronto - 1600 Etc/GMT - 1800 Europe/Berlin - 2130 Asia/Kolkata – Sun Jun 21 0000 Asia/Singapore
  • EmacsSF (in person): coffee.el in SF https://www.meetup.com/emacs-sf/events/315192115/ Sat Jun 20 1100 America/Los_Angeles
  • Emacs Berlin: Emacs-Berlin Hybrid Meetup https://emacs-berlin.org/ Wed Jun 24 1000 America/Vancouver - 1200 America/Chicago - 1300 America/Toronto - 1700 Etc/GMT - 1900 Europe/Berlin - 2230 Asia/Kolkata – Thu Jun 25 0100 Asia/Singapore
  • Emacs APAC: Emacs APAC meetup (virtual) https://emacs-apac.gitlab.io/announcements/ Sat Jun 27 0130 America/Vancouver - 0330 America/Chicago - 0430 America/Toronto - 0830 Etc/GMT - 1030 Europe/Berlin - 1400 Asia/Kolkata - 1630 Asia/Singapore
• Beginner:
  • How to Install a Package on Emacs From Melpa (04:09)
• Emacs configuration:
  • Replace shell-pop with built-in display-buffer-alist (Reddit)
  • salvari/emacs30_elpaca_public: My new configuration for Emacs using Elpaca as package manager - Codeberg.org (@salvari@mastodon.gal)
• Emacs Lisp:
  • Lars Ingebrigtsen: Web scraping is getting harder all the time
  • [22] Integrating Emacs Reader with Canvas - Dyne.org TV (@divyaranjan@mathstodon.xyz)
• Appearance:
  • halo.el: an experimental minor mode for keeping point centered and dimming distant lines (Reddit)
  • dimmer.el – after a hiatus, new development underway (Reddit) - dims inactive buffers; updates: reset when theme changes, handle child frames
  • Dave Pearson: Simplifying my mode line
  • Dave Pearson: It got darker - switched to a dark-mode
  • Inspired by nano-emacs: vertico-buffer-frame with nano-vertico (Reddit)
• Navigation:
  • modernizing bookmark+ (Reddit)- trying to get in touch with Drew Adams
  • outline-indent, a modern Indentation-based Text Folding Mode for Emacs (Release 1.2.0) (Reddit)
• Dired:
  • Protesilaos: Emacs: flat Dired listing for REGEXP, optionally up to DAYS since last modification (Irreal)
• Writing:
  • Bozhidar Batsov: Emacs loves AsciiDoc (Irreal)
  • Dave Pearson: blogmore.el v5.3.0 - adds blogmore-link-series
  • New, Fast, BibTex Formatter (Reddit) - Uses rust
• Denote:
  • TAONAW - Emacs and Org Mode: Meta Journal notes in Denote-Journal with Journelly
• Org Mode:
  • Sacha Chua: From DC Toedt: Copy Org Mode as Markdown
  • Raymond Zeitler: Creating a Reference to a Webpage in Org
  • A Day with Org-SuperTag — One Person's Complete Workflow
  • Org export dispatcher to Eisvogel LaTeX template
  • YAOB – Yet Another Org Blog · (interzone) (@cryptk)
  • Emacs Org-Roam: Gestione della Conoscenza a Grafi e Metodo Zettelkasten (06:39)
  • Org development:
    • ob-core: Obsolete `org-babel-remote-temporary-directory'
    • org-agenda-timerange-leaders: Allow functions as element values
• Completion:
  • Chris's Wiki - blog/programming/EmacsUnderstandingEmbark (lobste.rs, lemmy.ml)
• Coding:
  • James Dyer: The Hidden Git Stash Keys in Emacs VC Directory Mode
  • Configuring Emacs for Swift Development | Swift.org (@kickingvegas@sfba.social)
  • Common Lisp tree-sitter grammar with a major-mode and Sly powered semantic highlighting (Reddit)
  • Corrigindo divergências entre arquivos de configuração do emacs (01:37:06)
• Mail, news, and chat:
  • mu4e-based email automation package (Reddit)
  • Whatsappel - Run WhatsApp inside Emacs (Reddit)
• Doom Emacs:
  • doom emacs 项目拆分为core和modules, doom emacs 将进入快速发展期 (Reddit)
• Fun:
  • The World Cup… in emacs! ⚽️💻 (04:41, Reddit)
  • Emacs SVG Benchmark Reveals Gaming-Caliber Frame Rates (Reddit)
• AI:
  • Alvaro Ramirez: agent-shell 0.55 updates (lobste.rs, Reddit)
  • New Pi Emacs coding harness release has no trust issues! (Reddit)
  • EMCP - Emacs an an MCP server (Reddit)
  • Vibe Coding with Emacs' Built-In AI - System Crafters Live! (01:47:29)
• Community:
  • Joshua Blais on Doom Emacs, Vanilla Emacs, Guix, and 34-Key Keyboards (Reddit)
  • Raymond Zeitler: Emacs – It's Worth Revealing Oneself For
  • My Blog Now Has a Gemini Mirror (Reddit) - Rahul Juliato
• Emacs Carnival: Underappreciated Built-ins:
  • Even More Batteries Included With Emacs (Karthinks) (Reddit, HN, lobste.rs)
  • Yay Emacs 33: Sacha and Prot Talk Emacs: Built-ins (01:01:36)
  • Emacs carnival: rec mode, an all-text database system (lobste.rs)
• Other:
  • tanrax/emacs-gpu: GNU Emacs with a GPU-accelerated display backend · GitHub (@andros@activity.andros.dev)
  • Xah Talk Show Ep793. emacs, install Xah Fly Keys in WSL linux emacs (02:18:11)
  • Xah Talk Show Ep792. install emacs on wsl Windows Subsystem for Linux (01:47:31)
  • Sacha Chua: Yay Emacs 33: Sacha and Prot Talk Emacs: Built-ins (Prot)
  • Chris Maiorana: When tmux is your window manager (Irreal)
• Emacs development:
  • emacs-devel:
    • Re: master 1d91d9b717d: project-vc-dir: Use truenames - Dmitry Gutov - discussion of when to use symlinks and when to use truenames
    • Re: SDL terminal type - Lina - anyone interested in trying to port Emacs UI to SDL rendering?
  • Optional display of overlay-arrow in margin (bug#81109)
  • Revert "project-vc-dir: Use truenames"
  • Convert outline-search-function to defcustom
  • Add outline-search-from-regexp generic helper
  • 'work-buffer–release' kill locals silently and reset the buffer (bug#81111)
  • Set user options in file/directory locals like 'setopt-local' (bug#81120)
  • Add outline-show-entry-and-parents to reveal entry hierarchy
  • Mark vc-dir-show-outgoing-count obsolete
  • project-vc-dir: Use truenames
• New packages:
  • pure-light-theme: A light colored theme for e-ink color monitors (MELPA)
  • shexc-ts-mode: Tree-sitter major mode for ShExC (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 comment on Mastodon or e-mail me at sacha@sachachua.com.

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.

Update [2026-06-15 Mon 10:06]: Fixed link to Prot’s post.

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 more surprising and useful finds, so it’s time again for a “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

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, and you can copy a fixed number of characters from above with a numeric prefix argument (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 from 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 useful 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 invisible 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 on the fly 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 a 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-window always do-what-you-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 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 an expansive story, 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 me a few more years of typos to stumble onto them. Until then, happy Emacsing!

writing

I have been thinking of Separate Writing and Formatting. This is an interesting discourse on the need to separate the acts of writing from the act of preparing to present. I agree with the premise.

The Notion of a Canvas

Conceptually I look on the task of writing as starting with a blank canvas. The words then come in and fill the page. I don’t think of how it will look on the final document. Most of the time, I don’t care for the output. It is going to remain a text document in the Org format or Markdown format, depending on what I need.

The Different Types of Writing

I do two kinds of writing. The first kind is stream of consciousness writing. I have some idea of the topic and I type. I don’t know the topic completely, or don’t know how I feel about it. It is the act of writing that sheds light on my opinions or feelings. It is a dialog with myself. There is not much structure to it, but there is the belief that structure will come. After I have exhausted my exposition of the idea/topic on the page do I go through the task of editing and structuring. I like this process.

The second kind of writing I do is when I start with the structure. I think this is dependent on the topic I am writing on. If I know the topic well or have clearly formed ideas about the topic does this kind of writing work. I start with the structure. The structure leads me to the nature of the argument I am making. Once I have the structure laid out, I fill in the meat to the structure by writing it out. This process seems to lead to two diverse results. The structure changes. The argument flows differently. Most of the time, the arguments become more nuanced. Very few things in life are black or white. The calibration of the argument leads to nuances and an abundance of grays.

Most of the time, the writing happens in Emacs. Org-mode in Emacs. That has the advantage of being conducive to structure or the lack of it.

I notice that I like switching the applications around without any conscious thought. Sometimes, like this document I am working on, it starts as an OmniOutliner document. When I am done with it, this is going to get exported to a plain text file. It is going to be opened in Emacs for a look through or iA Writer for editing. Only after that will it be exported to the format I need to share (Markdown, PDF, Word, or HTML).

Necessary Conditions

• I want the document to be full-screen. I don’t want distractions.
• I want typewriter scrolling. I hate looking at the bottom of the screen all the time when I write.
• I want to be able to focus on sections/paragraphs when I write.

OmniOutliner has the ability to let me focus on sections of the document. It lets me reduce the noise and concentrate on a section of the document and ignore everything else. I can concentrate on writing a particular section and not be affected by the others. iA Writer has the ability to focus on a paragraph or on a sentence, and I have been using that for a long time.

In Emacs, I can achieve the same effect by calling a function recursive-narrow-or-widen-dwim. It performs the same task of narrowing my focus to the section that I am writing. Call it again, and you are back to the whole document. This is from the package Recursive Narrow.

They are Separate

The act of writing and the act of organizing the writing are separate activities. I find myself more productive when I am conscious of the separation and make sure that I am not allowing one to bleed into the other. Obviously during the editing phase, it becomes one. The act of structuring the argument leads to both changes to the structure and some changes to the nature of the content. This is my writing process.

The iA Folks

The iA folks make the argument that writing and formatting should be different steps. I have no disagreement with that view. I think the process of writing, structuring, editing, and formatting are all better off being different steps. Those are separate functions and my writing improves when I am conscious of that.

Is Writing Hard?

Thinking is hard. Writing is thinking. So writing is hard.

This is not prophetic. Everyone knows this. The question which is relevant here is how do you make it easier?

I don’t have the answer.

I made it easier for myself by sticking to a process. Whatever process you are comfortable with and have repeated success with is the cure to your problem with writing. It is not the same for everyone. Nor is the same process the most efficient for the same person all the time. That is the logic behind me relying on a mixture of applications to produce my writing. It works for me. Your mileage may vary.

Presentation is Integral to Influence

Presentation of any kind of writing is a crucial part of the process of influence. Structure and Formatting are elements of that effort. I must admit that I am not an expert in this field. In other words, I have no idea how to make a document look persuasive. I concentrate on the contents of the document, the structure of the argument and the cleanliness of both the content and the presentation. That is the extent of my effort at persuasion through presentation.

This is a nice way of saying that I don’t concentrate on the presentation as much as I should. I try to persuade with my content rather than the presentation of said content. I don’t know whether that is the best solution but that is what I find myself doing. Most of my writing is for myself. I am persuaded, that is why it came out the way it did. Persuading other people? I am not so sure.

Takeaway

I am sure that the process is important. Separate the functions of writing, editing, and formatting into discrete tasks, because they are. Vomit it all out on the page, then edit and format the content to ensure that you are presenting well thought-out, reasoned arguments. That is the key to persuasive writing.

macosxguru at the gmail thingie.

Thanks to: Photo by Pixabay: https://www.pexels.com/photo/remington-standard-typewriter-in-greyscale-photography-163116/

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!

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

Related links:

• Underappreciated Emacs Built-ins
• Top (GNU Emacs Manual)
• YE24: Sacha and Prot Talk Emacs - Newbies/Starter Kits
• Emacs: decent defaults I shared with Sacha Chua | Protesilaos
• EmacsWiki: Carnival