Irreal: Emacs In Pop Culture

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.

-1:-- Emacs In Pop Culture (Post Irreal)--L0--C0--2026-06-10T15:35:57.000Z

Chris Maiorana: When tmux is your window manager

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.

-1:-- When tmux is your window manager (Post Chris Maiorana)--L0--C0--2026-06-10T11:56:45.000Z

Dave Pearson: blogmore.el v5.0.0

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 beneficial1 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.

The current menu

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.


  1. The benefits being: only values in frontmatter appear, inconsistent casing is cleaned up, etc. 

-1:-- blogmore.el v5.0.0 (Post Dave Pearson)--L0--C0--2026-06-10T09:22:12.000Z

James Dyer: The Hidden Git Stash Keys in Emacs VC Directory Mode

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:

20260610061920-emacs--The-Hidden-Git-Stash-Keys-in-Emacs-VC-Directory-Mode.jpg

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.

-1:-- The Hidden Git Stash Keys in Emacs VC Directory Mode (Post James Dyer)--L0--C0--2026-06-10T05:19:00.000Z

Rahul Juliato: This Blog Now Has a Gemini Mirror

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!

-1:-- This Blog Now Has a Gemini Mirror (Post Rahul Juliato)--L0--C0--2026-06-09T20:55:00.000Z

Sacha Chua: From DC Toedt: Copy Org Mode as Markdown

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:

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))
View Org source for this post

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

-1:-- From DC Toedt: Copy Org Mode as Markdown (Post Sacha Chua)--L0--C0--2026-06-09T15:49:08.000Z

Dave Pearson: blogmore.el v4.7.0

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.

Selecting a series

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...

-1:-- blogmore.el v4.7.0 (Post Dave Pearson)--L0--C0--2026-06-09T07:42:40.000Z

Sacha Chua: June 11: Sacha and Prot Talk Emacs: Built-ins

On June 11, I'm going to chat with Prot about the Emacs Carnival June 2026 topic Underappreciated Emacs Built-ins. Thanks to Ross A. Baker for hosting the carnival!

(America/Toronto) = Thu Jun 11 1030H EDT / 0930H CDT / 0830H MDT / 0730H PDT / 1430H UTC / 1630H CEST / 1730H EEST / 2000H IST / 2230H +08 / 2330H JST

View Org source for this post

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

-1:-- June 11: Sacha and Prot Talk Emacs: Built-ins (Post Sacha Chua)--L0--C0--2026-06-09T02:51:39.000Z

Protesilaos: Emacs live with Sacha Chua about ‘Underappreciated Built-ins’ on Thursday 11 June 17:30 Europe/Athens

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

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

The video will be recorded for future reference.

-1:-- Emacs live with Sacha Chua about ‘Underappreciated Built-ins’ on Thursday 11 June 17:30 Europe/Athens (Post Protesilaos)--L0--C0--2026-06-09T00:00:00.000Z

Sacha Chua: 2026-06-08 Emacs news

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

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!

View Org source for this post

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

-1:-- 2026-06-08 Emacs news (Post Sacha Chua)--L0--C0--2026-06-08T18:36:11.000Z

Raymond Zeitler: Emacs and the Numeric Keypad

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

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

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

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

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

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


https://en.wikipedia.org/wiki/Numeric_keypad
-1:-- Emacs and the Numeric Keypad (Post Raymond Zeitler)--L0--C0--2026-06-08T15:51:22.851Z

Irreal: Elfeed 4.0.0

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

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

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

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

-1:-- Elfeed 4.0.0 (Post Irreal)--L0--C0--2026-06-08T14:46:14.000Z

Charlie Holland: svg-line: Better Status Bars for Emacs

1. TLDR

Emacs provides four useful status bars (mode-line, header-line, tab-bar, and tab-line), but each imposes different, inconsistent limits on multi-line layout, alignment, icons, and interactivity. svg-line (see code on GitHub) solves this by rendering them as SVG images, and normalizes a rich feature set across all status bars with a consistent configuration. svg-line works by defining a small rendering engine built on Emacs's native SVG support. Configuring status bars is easy: you simply write one :content function and call svg-line-activate. You can see my custom configuration of mode-line, header-line, tab-line, and tab-bar in my Emacs config.

svg-line-annotated.png

Figure 1: Every *-line in this frame is one SVG image drawn by svg-line.

2. About

Emacs gives us four status bars, the mode-line, the header-line, the tab-bar, and the tab-line (*-lines for short). These are useful for providing a dynamic 'heads-up display', for important context, like what buffer you're in, the active major mode, and really any arbitrary thing you can define.

I'm a heavy user of the *-lines in Emacs, and I have them all enabled, but the issue that has plagued me is that, natively, each one behaves differently and each has unique limitations. For example, multi-line status (necessary on my small laptop) is possible, but only in the tab-bar. Right alignment is possible in the tab-bar, but only in the last line, and this alignment feature is only available in the tab-bar. I can display icons from all-the-icons in the mode-line and header-line, but not the tab-bar or tab-line. Etc….

What I really want is consistent behaviour and configuration across all these status bars, and I want the multi-line, alignment, and icons features available in all of them. It turns out that SVG (scaled vector graphics) is the key to solving this.

Inspired by Nicolas Rougier's dual-header gist, I built svg-line, which provides this experience by utilizing Emacs's built-in SVG rendering support. At first, this approach seemed like a hack, or abuse of the *-lines, or neglect of the built-in status bar behaviour. But I kept it and created a package because I was literally shocked how well this works and how native this feels (see the screenshot and video above).

Note that even if you only use the mode-line, svg-line is still useful — likely more so, since a single status bar has to render all your indicators on its own.

3. svg-line's Features

  • Multi-line everywhere, with per-row left/center/right alignment.
  • A tab-line that wraps overflowing tabs onto new rows instead of hiding them, including with file-type glyphs, a current-tab highlight, and an unsaved tint.
  • Clickable anything. Any segment can carry a left-click action, a right-click menu, and hover help with a highlight. This works uniformly across all four bars, including the otherwise-uncooperative tab-bar.
  • Icons as text. Using Nerd Fonts and an icon is just a character that flows with everything else. SVG rendering also enables a full-height "masthead" glyph option on status bars that can span multiple lines.
  • Dynamic and animated indicators: a buffer-position pie, progress bars, active vs. inactive styling per window.
  • It respects text scale. The bars track text-scale, re-rendering crisply instead of blurring.

A meta feature is that the configuration surface is uniform across all status bars, which is a pleasant improvement over the diverse configuration strategies for the native APIs.

4. Why SVG Works

When using svg-line, each line becomes one SVG image, and SVG images are more featureful than the native text engine:

  1. It can be any height. Multi-row bars are now possible in every *-line.
  2. Everything is placed at exact pixel coordinates. Left, right, and center alignment work identically on every row.
  3. It draws whatever you want. Text, yes, but also wrapped tab flows, geometric progress bars and pies, and (with a Nerd Font) icon glyphs inline with the text, the same on all four lines. Anything you can render in an SVG (just about anything) is fair game.
  4. The engine remembers where it drew. It can detect the mouse against those placements, so clicks, right-click menus, and hover all work on any element of any line.

5. Configuration

Configuring svg-line is deliberately simple. You write a :content function that returns rows, supply it to svg-line-define, and call svg-line-activate on the defined line. This configuration pattern is identical for all four bars. The engine has two layouts: lines (the default — rows of segments, used for the mode-line, header-line, and tab-bar) and wrap (a flow that wraps, used for the tab-line).

5.1. Mode-line

5.1.1. Simple mode-line

The smallest useful line is a single row: a label on the left, the cursor position on the right.

(svg-line-define 'my-mode-line
  :target 'mode-line
  :content (lambda ()
             ;; one row: (LEFT-SEGMENTS . RIGHT-SEGMENTS)
             (list (cons (list (buffer-name))
                         (list (format-mode-line "%l:%c"))))))

(svg-line-activate 'my-mode-line)

This trivial example clarifies the pattern: define then activate:

  • :content is the only required key: a function returning a list of rows. Each row is a (LEFT . RIGHT) cons, and each side is a list of segments — here just plain strings.
  • with no :background, :foreground, or :active, the line picks sensible defaults and is always drawn as active.
  • svg-line-activate enables it, and svg-line-deactivate / svg-line-toggle disable it, restoring the native mode-line untouched.

5.1.2. Rich mode-line

Here's a more complicated mode-line configuration that demonstrates svg-line's feature scope. It defines two rows, three-way alignment, a masthead icon, a custom segment, a clickable button, dynamic theme colours, and active/inactive styling:

;; A custom segment is just a zero-argument function returning a string.
;; This one shows how far point sits through the buffer, as a percentage.
(defun my/buffer-percent ()
  (format " %d%%" (/ (* 100 (point)) (max 1 (point-max)))))

(svg-line-define 'my-mode-line
  :target     'mode-line
  :active     #'mode-line-window-selected-p
  :icon       (lambda () (nerd-icons-icon-for-mode major-mode))
  :background (lambda () (face-background 'mode-line nil t))
  :foreground (lambda () (face-foreground 'default nil t))
  :content
  (lambda ()
    (list
     ;; row 1 — three independently-aligned segments on one row
     (list :left   (list (buffer-name))
           :center (list (symbol-name major-mode))
           :right  (list (format-time-string "%H:%M")))
     ;; row 2 — custom segment + position on the left, a button on the right
     (cons (list #'my/buffer-percent (format-mode-line " %l:%c"))
           (list (svg-line-seg "save"
                               :id 'ml-save
                               :help "buffer actions"
                               :action #'save-buffer
                               :action-help "save"
                               :menu '(("Revert" . revert-buffer)
                                       ("Kill"   . kill-current-buffer))))))))

(svg-line-activate 'my-mode-line)

Line by line:

  • my/buffer-percent — any zero-argument function can be a segment; this one returns a string.
  • :active #'mode-line-window-selected-p — a predicate; when it's false (an unfocused window) the engine applies the :inactive-* colours instead.
  • :icon — a full-height "masthead" glyph drawn once on the left edge, spanning both rows. This is a function, so it tracks the current buffer's mode.
  • :background / :foreground — literal colours, or (as here) zero-argument functions evaluated on every render, so the bar follows your theme automatically.
  • row 1 — a :left/:center/:right plist puts three independently-aligned segments on a single row.
  • row 2 — a plain (LEFT . RIGHT) cons. Its left side mixes the custom function with an ordinary %l:%c string.
  • svg-line-seg — turns a segment into a button: left-click runs :action, right-click opens the :menu, and :help shows on hover in the echo area.

5.2. Tab-line

The tab-line is where the wrap layout is most useful: instead of scrolling overflow off the edge, it flows tabs onto subsequent rows.

(svg-line-define 'my-tab-line
  :target  'tab-line
  :layout  'wrap
  :content (lambda ()
             ;; each item is (LABEL . STATE)
             (mapcar (lambda (buf)
                       (cons (buffer-name buf)
                             (list :current  (eq buf (current-buffer))
                                   :modified (buffer-modified-p buf))))
                     (tab-line-tabs-window-buffers)))
  :current-background  (lambda () (face-background 'highlight nil t))
  :modified-foreground "#ebcb8b")

(svg-line-activate 'my-tab-line)
  • :layout 'wrap — switches from rows of segments to a wrapping flow; overflowing tabs land on a new row rather than scrolling out of sight.
  • each item is (LABEL . STATE), where :current and :modified in the state plist drive the per-tab highlight and unsaved tint.
  • :current-background / :modified-foreground — the same value-or-function styling as the lines layout, just with current- and modified-tab variants.

6. Acknowledgement

Credit where it's due: this started as an experiment off Nicolas Rougier's work. His SVG explorations and that dual-header gist demonstrated that this was possible, and showed me how well this approach works.

-1:-- svg-line: Better Status Bars for Emacs (Post Charlie Holland)--L0--C0--2026-06-08T11:58:29.000Z

Sacha Chua: June 18: Emacs Chat with Ross A. Baker

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

America/Toronto = Thu Jun 18 1030H EDT / 0930H CDT / 0830H MDT / 0730H PDT / 1430H UTC / 1630H CEST / 1730H EEST / 2000H IST / 2230H +08 / 2330H JST

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

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

View Org source for this post

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

-1:-- June 18: Emacs Chat with Ross A. Baker (Post Sacha Chua)--L0--C0--2026-06-07T18:28:45.000Z

Irreal: Correcting The Orientation of macOS Photos on Linux

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

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

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

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

-1:-- Correcting The Orientation of macOS Photos on Linux (Post Irreal)--L0--C0--2026-06-07T14:12:28.000Z

Bicycle for Your Mind: Much Ado About Emacs 014

EmacsEmacs

Org-Mode and the Capture System

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

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

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

Org-captureOrg-capture

You get this.

Journal EntryJournal Entry

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

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

My setup for the journal capture looks like this:

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

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

The explanation:

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

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

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

Tweaking the Capture System for Bookmarks

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

BookmarkBookmark

I came up with a capture template:

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

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

Org-captureOrg-capture

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

Bookmark ChoicesBookmark Choices

Press b and I get this.

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

Makes it easy.

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

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

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

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

Tweaking Org-mode

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

New Org Header Outside/Inside

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

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

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

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

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

Tweaking Some More

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

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

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

This is all I have for today.

macosxguru at the gmail thingie.

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

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

Note: I had help from Ollama with the code.

-1:-- Much Ado About Emacs 014 (Post Bicycle for Your Mind)--L0--C0--2026-06-07T07:00:00.000Z

Sacha Chua: Emacs PDF View: Replace current page with file using PDFtk

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

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

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

-1:-- Emacs PDF View: Replace current page with file using PDFtk (Post Sacha Chua)--L0--C0--2026-06-07T00:35:27.000Z

Raymond Zeitler: Follow-on to exeln

Sebastián Monía1 offered some alternatives to the exeln function that I posted on June 4.2

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

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

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

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

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

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

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


1 https://site.sebasmonia.com/
2 exeln-execute-line.html
3 GNU Emacs online shell-command help
-1:-- Follow-on to exeln (Post Raymond Zeitler)--L0--C0--2026-06-06T23:41:48.603Z

Irreal: Emacs 31.0.90 Pretest

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

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

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

-1:-- Emacs 31.0.90 Pretest (Post Irreal)--L0--C0--2026-06-06T14:42:58.000Z

Marcin Borkowski: Copying images in Emacs

A few weeks ago I was on vacation. Of course I brought back quite a few pictures with me. When I got back, I sat to select some of them to make a gallery for my family and friends. I started with copying all pictures from two mobile phones and a camera to my laptop. Then I wanted to copy a few carefully chosen images to one directory. To my surprise, Emacs’ Image mode does not have a command to copy the currently viewed image to another directory.
-1:-- Copying images in Emacs (Post Marcin Borkowski)--L0--C0--2026-06-06T04:54:01.000Z

Dave Pearson: blogmore.el v4.6.0

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

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

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

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

-1:-- blogmore.el v4.6.0 (Post Dave Pearson)--L0--C0--2026-06-05T19:01:30.000Z

Lars Ingebrigtsen: Super Simple Spam Splitting for Gnus

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

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

Tada!

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

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

B t to check the split trace, as normal.

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

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

-1:-- Super Simple Spam Splitting for Gnus (Post Lars Ingebrigtsen)--L0--C0--2026-06-05T11:44:55.000Z

Raymond Zeitler: exeln: EXEcute LiNe

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

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

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

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

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

2026-06-04 Add demo video

-1:-- exeln: EXEcute LiNe (Post Raymond Zeitler)--L0--C0--2026-06-04T17:53:49.163Z

Charles Choi: Revisiting Emacs Keyboard Macros with a Mouse

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

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

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

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

img

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

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

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

-1:-- Revisiting Emacs Keyboard Macros with a Mouse (Post Charles Choi)--L0--C0--2026-06-04T16:35:00.000Z

Irreal: Inhibit The Mouse In Emacs

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

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

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

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

-1:-- Inhibit The Mouse In Emacs (Post Irreal)--L0--C0--2026-06-04T15:20:56.000Z

Sacha Chua: Emacs Chat 25: Ben Zanin (@gnomon@mastodon.social)

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

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

Chapters

  • 0:00 How Ben got started with Emacs
  • 2:19 Ben got into Emacs because of twittering-mode
  • 4:30 Emacs as a media playback platform with Versuri and Mpdel
  • 9:13 Emacs on Android with Termux
  • 13:44 Keyboards and other devices
  • 16:44 Benefits of a split keyboard
  • 18:22 Meeting workflow
  • 21:11 Narrowing
  • 22:58 There's even an internal Slack channel about Emacs at Ben's company
  • 24:50 Ben keeps Org capture templates as individual files and adapts them to different meeting flows
  • 28:45 Personal-scale software and the journey
  • 34:07 vc-git-grep for finding notes again
  • 37:47 Keybindings and terminals; wezterm
  • 42:38 Timers: tea-timer, tmr
  • 43:57 Different stages of package use
  • 44:47 Elfeed
  • 53:13 Bookmark naming conventions
  • 53:50 elfeed-curate for annotations
  • 55:46 mytoots archives Mastodon toots
  • 57:05 Mentoring offer
  • 58:02 A local instance of public-inbox can let you use Gnus to read mailing lists quickly

Transcript

Still needs editing

Expand this to read the transcript

0:00 How Ben got started with Emacs

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

Ben: Oh, Zanin.

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

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

Sacha: Oh no!

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

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

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

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

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

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

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

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

Ben: No, it's deeply embarrassing.

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

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

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

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

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

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

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

Sacha: Please.

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

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

Ben: Absolutely, yeah.

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

Ben: Is that better?

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

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

Sacha: You can play stuff on this...

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

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

9:13 Emacs on Android with Termux

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

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

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

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

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

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

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

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

Ben: Straight Magit mode.

Sacha: Oh, yeah?

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

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

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

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

Ben: Yeah, me too.

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

Ben: Yes.

Sacha: Okay.

13:44 Keyboards and other devices

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

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

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

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

Sacha: Many Emacs people have keyboard problems.

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

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

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

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

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

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

16:44 Benefits of a split keyboard

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

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

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

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

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

Sacha: That's okay.

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

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

18:22 Meeting workflow

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

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

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

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

21:11 Narrowing

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

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

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

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

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

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

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

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

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

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

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

Ben: Yeah. Bunch of nerds.

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

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

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

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

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

Sacha: Wow, that sounds pretty sophisticated.

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

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

Ben: Exactly, yeah.

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

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

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

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

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

28:45 Personal-scale software and the journey

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

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

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

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

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

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

Ben: So it's usually like an Org Mode per category and they get consolidated. Let me shrink this down a little bit. So usually it's an Org Mode category per file. If there's something super specific, then usually it'll kind of live out in its own place until I get around to... I love that you have an Org File specifically for Mud Cake. But that's the thing. It'll live off in its own thing until it gets integrated into the list where the long-term stuff lives. So, for example, I promise this is pertinent to your actual question.

Sacha: No, no, this is very pertinent.

Ben: But so like usually lots of little files while I'm still working on something and then as that something becomes part of my larger life and has links to other things then it'll kind of get centralized into one of the Org Mode files that has a broader topic purpose basically.

Sacha: Okay and then if you if it's like very long term and you can't remember the exact rates to find something how do you generally find find your notes?

Ben: That way.

Sacha: All right. You start graphing various keywords and try to find it.

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

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

Ben: So I don't have anything to show yet, except that it's an interesting topic because... Because I'm word-oriented, I will often remember individual keywords or I'll have enough patience that I can sift through a list of potential keywords as I'm grepping for stuff. And if I find that my first three or four attempts at searching for a keyword don't find the topic that I'm looking for, once I do eventually dig up the topic, I will add those keywords that I was searching for just so I can find it next time, expecting that future me will probably behave more or less like current me. But yeah, like being able to use a vector database to search for headings that include related topics instead of related words. I'd really like to get there. I'm not there yet. And I think that's going to be interesting and useful. I also think it's going to be challenging to kind of represent Org modes. hierarchical structure to restrict the training of particular vector sets to be able to find like an increasingly or cast an increasingly wide net for where I want the searches to run. So I don't know how that's going to be solved yet, but I'm going to be looking into it.

37:47 Keybindings and terminals; wezterm

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

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

Sacha: Oh yeah?

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

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

Ben: Infuriating.

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

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

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

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

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

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

42:38 Timers: tea-timer, tmr

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

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

43:57 Different stages of package use

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

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

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

Sacha: But yeah, elfeed.

44:47 Elfeed

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

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

Sacha: You've got tags now.

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

Sacha: I love the comments.

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

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

Ben: Yeah, I mean, so again, my use of YouTube is also deviant in that I pretty much strictly subscribe to RSS feeds and they're downloaded onto the file server. So when a new recording comes out, it gets dropped there. I'll watch it. And then I've got a little widget that scans through my Kodi database for watched files. Once YouTube files show up in the watch list, they're automatically purged. And it means I just never see an ad. It's not just satisfying. I don't think that I would be able to pay attention if I was being constantly interrupted because of the way that my brain works. But yeah, so being able to quickly search for YouTube is one thing. I do have... articles that I've marked as spoilers for media that I haven't watched or read yet. Maybe I go to an extreme degree, but I'll try to avoid previews for new movies, for example. But I do want to actually go back to them later on. Marking articles as having spoilers that I want to revisit later on is an easy way of not having to worry about it anymore. And for a while, back in the days when I was paying more attention to... Enter the Dragon was the sequel to... What was that TV show? The George R.R. Martin seven seasons and it went badly off the rails in season six.

Sacha: Game of Thrones.

Ben: Thank you. So when I was watching that for a while, several of the sites that I was reading would have individual episode updates. And I really appreciated having a list of Elfie keywords that I could automatically apply those tags to. So I wouldn't even see the headlines because it was problematic enough. I've become less... Nice. Yeah, I've been putting less effort into maintaining that now, but the infrastructure is still there and I can lean on it if I need to. One of the things that I don't have set up right now is a quick search for the municipal topics that I cover. So I tend to subscribe to a lot of news because I found that, for example, it's interesting to see how the Toronto Star covers stuff differently from other local newspapers. And it's useful to be able to quickly pull up You know, the five or six publications that cover news in the same way and then look through the annotations for them or add the annotations myself so I can see that this particular story was covered by this journalist in this publication in this way and then it lets me cross-reference so that I can pay attention to Topics that are under-covered or publications that habitually leave out particular aspects of news stories. It lets me pay more attention to The trends of publications as well as to the stories that they're covering. But the consequence of that is that my LFE database is like four and a half gigs. And it's common for me, actually, I don't know if that actually shows. It's common for me to have like 65,000 articles in like the six month horizon for the default LFE searches. And that means that searches and redraws are expensive, even on a relatively performant machine. So you've probably seen some of the workarounds that I've got. And this little bookmark selector is one of those workarounds. So L feeds interactive search, super, super useful. But if you're trying to do it like this, actually, it's not so bad.

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

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

Sacha: And then it's like bookmark annotation. right and like this is also it ends up in my dot file so as a git config as a as a git commit but

53:13 Bookmark naming conventions

Sacha: now that that bookmark exists simply because of the naming uh lfe search now it shows up in completion precisely this sort of stuff I I am under utilizing bookmarks I think but I like that I love this idea of using bookmarks with a naming convention and then writing Emacs list but take advantage of that naming convention to make that easy to jump to easy to use in other things

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

Sacha: Very cool.

53:50 elfeed-curate for annotations

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

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

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

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

Sacha: Sorry, you need to kill the stream and have a 10-second video.

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

Sacha: Yeah, yeah. Huh. Very cool.

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

55:46 mytoots archives Mastodon toots

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

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

57:05 Mentoring offer

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

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

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

Ben: Please, I would love that conversation.

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

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

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

Sacha: That's great because like Emacs develops like gazillion threads and how do you even keep track of all this stuff but if you've got news and you and if you've got this set up then you're no longer dependent on the good graces of Gmail being around as a kind of NNTP to mailing list gateway so uh so yeah uh John wants to know if you have YouTube like if you have a YouTube channel I'm guessing you don't yet but uh again I don't really like my face very much Ping Ben on Mastodon and ask about this mentoring thing and then share your notes so we can all learn from it. Thank you so much for today. I look forward to chatting with you more through toots. What is the verb, you know, in the 30-verse? All right. Thank you so much. All right. Bye. Okay, folks. I'll end the stream too. Bye. Thanks for hanging out.

Chat

  • sachactube: ​​only slightly panicking behind the scenes 🙂 Nudged Ben by Mastodon in case we got our wires crossed
  • sachactube: ​​yay, he's here, just getting sound sorted
  • symbiopoyesis: Good morning
  • x_goose_x: ​​hey gnomonnnnnn
  • CharlieBaker707: ​yay! love the split keyboard. recently bought one myself. i was getting shoulder and neck pain from so many hours keeping by hands close together, but the split let's my shoulder's relax.
  • ShaeErisson: ​How do you make a capture template to stay on-agenda and record decisions? Any tips?
  • PuercoPop: ​​Regarding terminal emacs, did they need to adapt any keybindings to avoid clashses with the terminal keybindings?
  • AyanRaza-n1x: ​​is that the creator of emacs?
  • Ray-On-Emacs: ​Yes! Google steals C-S-k, which I use to kill tabs to the right on Vivaldi!
  • CharlieBaker707: ​elfeed is like a distraction alleviation machine. I agree with Ben, I don't think I could consume any of this information outside of Emacs. Ads and even varying formats distract me too much.
  • JonKishore11: ​​do he have YT
  • sachactube: ​​Thanks for hanging out, everyone! =)
  • gnomon027: Thanks so much for running this whole series, @sachactube !!
View Org source for this post

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

-1:-- Emacs Chat 25: Ben Zanin (@gnomon@mastodon.social) (Post Sacha Chua)--L0--C0--2026-06-04T12:50:07.000Z

TAONAW - Emacs and Org Mode: Correcting photo orientation for org-mode in Linux

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

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

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

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

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

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

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

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

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

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

-1:-- Correcting photo orientation for org-mode in Linux (Post TAONAW - Emacs and Org Mode)--L0--C0--2026-06-03T12:29:09.000Z

Lars Ingebrigtsen: Todo Lists and Procrastination

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

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

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

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

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

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

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

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

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

The system works!

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

I sort of… postpone the procrastination.

Anyway. That’s the life hack.

-1:-- Todo Lists and Procrastination (Post Lars Ingebrigtsen)--L0--C0--2026-06-03T10:34:21.000Z

Charlie Holland: Beyond ICR: Incremental 'Suggesting' Read in Emacs

1. TLDR

This is the sixth post in my series on Emacs completion. The first argued that Incremental Completing Read (ICR) is a structural property of an interface, not an interface itself; the next four made it concrete with the VOMPECCC framework, my Spotify client (spot), a produce picker, and a VOMPECCC showcase. This one coins a term for a special case, Incremental Suggesting Read (ISR), where the candidate set produced by incrementally typed input is a suggestion, rather than a literal completion of that input. The ability to generate inferred matches in addition to literal matches vastly expands the scope of what a 'completion' system can do. Two conceptual sources supply the suggestions: 1) semantic retrieval and 2) generative synthesis.

This post is more speculative than useful, so carry that pinch of salt with you as you watch the video or read this post.

2. From completing to suggesting   icr isr definition

The initial post in this series broke down the 3 key words in ICR: read (type input), completing (match input against a candidate set), and incremental (recompute matches on every keystroke).

ISR is perfectly analgous, except the materialized candidate set is not a list of literal match candidates, but rather a list of inferred suggestions.

Put another way, in completing read, the candidates lexically correspond to your input. In suggesting read, a model infers candidates from your input.

In this post and video above, I discuss two sources of ISR:

  1. Semantic retrieval: the candidates are generated from concrete, existing data (notes, mail, code), and ISR ranks them by meaning, or semantic proximity to the input. A well established demo of this in Emacs is John Kitchin's "semantic completing read", which ranks Org files by embedding similarity to what your input 'means'.
  2. Generative synthesis: the candidate is written on demand (by an LLM) and is effectively non-existent prior to your input, which can appropriately be called a 'prompt' in these cases.

3. The same machinery, a different source   substrate thesis

Because Emacs built-ins (and of course VOMPECCC) are so strong, they can be used to support ISR use-cases. Everything we demonstrated in prior posts is relevant here, most of all the consult package.

The key enabler of ISR is the fact that completing-read's candidate collection can be a function: Emacs passes your input to a function, and that function returns the inferred suggestions. That's powerful in the abstract, and concretely it enables our semantic retreival and generative synthesis use cases.

Because Emacs clearly already supports this abstraction, everything downstream of the source (everything we've demonstrated in this series up until this point) is re-usable. In line with a common theme in Emacs, our precious, hard-earned muscle memory transfers perfectly from ICR to ISR.

consult is especially enabling of ISR because it is functionally optimized to supply candidates from a backend rather than a materialized list. We've already shown how we can hand consult a function (that hits an API) and consult supplies asynchronous fetching, keystroke debouncing, live preview, grouping, narrowing, and (optionally) Embark actions.

There are already public examples of ISR in action:

In the generative syntehsis case, an integration between 2 packages provides a beautful example. Armin's consult-omni ships with a consult interface to karthink's gptel in gptel source. This integration with gptel's suggesting backend is defined the same way as it would be with a completing backend, whether that's ripgrep or a search API. Another generative synthesis example would be completing for the possible LLM expansions of inline code or prose (think GitHub Copilot's Emacs extensions).

In the semantic retreival case, I implemented an example borrowing from John Kitchin's org-db-v3 for the embeddings.

The point of this section is that the existing ICR machinery (especially consult in this case) can be re-used for ISR. Below you can see how I reuse it. Pay special attention to consult--read and consult--dynamic-collection in my chiply-isr-semantic-read command:

(defun chiply-isr--collection (input)
  (mapcar (lambda (r)
            (cons (format "%-22s  %s"
                          (file-name-nondirectory (alist-get 'filename r))
                          (alist-get 'chunk_text r))
                  (alist-get 'filename r)))
          (chiply-isr--search input)))    ; embedding search over my sample corpus

;; consult drives that function as a live, per-keystroke source.
(defun chiply-isr-semantic-read ()
  (interactive)
  (find-file
   (consult--read
    (consult--dynamic-collection #'chiply-isr--collection
      :min-input 3 :debounce 0.3)
    :prompt "Suggesting read (by meaning): "
    :lookup #'consult--lookup-cdr
    :require-match t :sort nil)))

The suggesting --collection function is the only thing that differs from a completing character-matching source. The full chiply-isr module lives in my Emacs config, but I built it for this demo, so I don't recommend you use it.

4. What makes suggestion special   hci cognition

The primer praised ICR for its cued recall, an alleviation of the burden on recall, with a small tax on recognition. With ICR, you supply a fragment (almost an 'intuition' considering Orderless's flexible matching capabilities), then pay the incredibly cheap cognitive cost of recognizing your target from a winnowed candidate set.

ISR moves further from recall, and opens the door to speculation. In semantic retrieval you supply only a gesture at meaning, and in generative synthesis you supply a question. In this way, I think about the goal of ISR as exploration and discovery, and the goal of ICR as arriving at a destination.

In my opinion, ISR's real value props are 1) reaching candidates that literal matching can't (semantic retreival), and 2) providing detailed answers to open questions and possible expansions (generative synthesis).

5. Notes on the demo

The demos from the companion video, and where their code lives in my Emacs config:

  • Semantic retrieval (match candidates by meaning)
  • Generative synthesis (generated output from LLMs)
-1:-- Beyond ICR: Incremental 'Suggesting' Read in Emacs (Post Charlie Holland)--L0--C0--2026-06-03T08:41:15.000Z

Raymond Zeitler: Change Emacs Cursor to Indicate Overwrite Mode

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

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

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

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

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

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

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

2026-06-02 Move hook outside function

-1:-- Change Emacs Cursor to Indicate Overwrite Mode (Post Raymond Zeitler)--L0--C0--2026-06-02T23:00:38.304Z

Irreal: Sdcv-quick Update

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

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

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

-1:-- Sdcv-quick Update (Post Irreal)--L0--C0--2026-06-02T14:13:44.000Z

Bicycle for Your Mind: Much Ado About Emacs 013

EmacsEmacs

Update

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

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

anddo.el

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

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

My setup:

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

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

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

Substitute

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

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

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

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

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

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

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

And a general.el keybinding:

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

Code Folding

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

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

Sunk Cost

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

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

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

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

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

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

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

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

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

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

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

Emacs Bankruptcy

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

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

That is all I have for today.

macosxguru at the gmail thingie.

-1:-- Much Ado About Emacs 013 (Post Bicycle for Your Mind)--L0--C0--2026-06-02T07:00:00.000Z

Charles Choi: Opening macOS Finder Folders in Emacs with Scrim

img

TL;DR

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

“Open in Emacs” Shortcut iCloud Link

Motivation

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

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

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

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

Background

Scrim

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

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

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

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

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

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

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

Services

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

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

“Open in Emacs” Shortcut

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

img

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

1
2
3
4
5
6
7
import sys
from subprocess import call
from urllib.parse import quote

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

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

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

“scrim link” Shortcut

img

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

img

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

Closing Thoughts

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

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

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

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

-1:-- Opening macOS Finder Folders in Emacs with Scrim (Post Charles Choi)--L0--C0--2026-06-02T02:00:00.000Z

Jakub Nowak: Radical Builtins

This is my entry for the June 2026 Emacs Carnival Underappreciated Emacs Builtins. There is a lot of functionality in default vanilla Emacs that is certainly less talked about. I'm going to constrain myself to talking about specific functions that exist, instead of overarching themes like portability.

Regional Commands

Some commands in Emacs work in the current region/selection. This is useful with undo in particular, because you can undo a change that happened in a specific area instead of having to go back through the whole undo history (or using a package like vundo).

Buffer Narrowing

Focusing a single buffer down to just the contents you want to look at makes parsing large code files so much easier. It seems like a basic thing but it helps me out more often than one would think, even when writing to focus on a specific paragraph or sentence to edit in isolation.

Indirect Buffers

Being able to "clone" a buffer also seems like such a trivial functionality, but it has so many uses. I particularly like this for editing large pieces of inline C code in Chicken. First M-x clone-indirect-buffer, then narrow to the C code string, then change to C mode. The narrow-indirect package speeds up this process a bit, but all of this functionality is built in by default.

Register

These might not seem too distinct from bookmarks, which everyone and their grandmother knows about, but I don't see people talking about registers enough. I work with big repos, monorepos that usually contain code for all the internal packages, and multiple apps. Being able to quickly say "I wanna jump back here" is unbelievably valuable, especially in combination with jumping to definitions and the like.

Directory Local Variables

Directory local variables are a silent workhorse for me, and don't get enough love. Knowing that these exist will save you endless config time when working across projects with different standards. Or, in the case of working with Scheme, different Scheme interpreters in Geiser. I like working with both Chicken and Gambit, and being able to set the default in a project easily is so helpful, even though it is ultimately trivial.

This goes beyond basic variable customisation too, you get a whole eval hook to play with. Some example uses of this are to automatically log in to AWS when the project is opened, or automatically starting the project for debugging, etc.

Tramp

As I write this there haven't been many submissions for this carnival, but I feel like Eshell and Tramp will get a lot of mentions. While obviously I do use Tramp for accessing my other machines, something that I hear about less often is that Tramp can read and write into more places than just another remote machine via SSH. There's obviously using it for sudo, but it works great for accessing files inside of Docker containers too (useful when working with devcontainers), and that functionality extends to:

  • Podman.
  • Kubernetes.
  • Distrobox.
  • Even flatpak sandboxes.

Macros

Probably should go without saying that macros are a very useful part of Editor Macros, but I feel that the standard macro functions get overshadowed in discussions, usually by proper Lisp scripting.

Repetitive, one-off tasks are everywhere. Personally, one of the first few keybinds I memorised in Emacs (even before navigation) was F3, F4, and C-x e to record, stop recording, and execute a macro. This single feature has saved me countless hours in doing menial crap such as:

  • Inverting cond statements in Scheme.
  • Stripping whitespace, quotation marks.
  • Editing CSV columns.

And the list goes on. There's so many times that I have run into a task that is repetitive but automatable, but not likely to come up again so not worth scripting. Being able to go "well okay, let me just press F3 and do it once, then just C-x e until I'm done" has saved so much pain.

Scripting Things

This final section I want to dedicate to the variously useful elements of Emacs Lisp.

Timers

Automatically running shell commands or other things at a given time is great, and these are also easy to manage with M-x list-timers. Who needs cron jobs?

Advise

I see advise generally frowned upon on in scripting discussion (for good reason, it can make code messy), but knowing the feature exists is occasionally really helpful.

Take neotree, for example. I want the directory of neotree to be tab-local, so that I can switch between tabs and have it persist. Emacs' tab bar mode doesn't have any hooks for tab selection, but that doesn't matter, because we can make our own.

(defvar tab-bar-select-tab-hook nil "Hook for `tab-bar-select-tab'")
(advice-add 'tab-bar-select-tab :after (lambda (x) (run-hooks 'tab-bar-select-tab-hook)))

Likewise, neotree doesn't have any hooks for when the root changes, which I want to keep track of to automatically update the tab directory. Again, that won't stop me.

(advice-add 'neotree-change-root :after #'theurgy-change-tab-dir)

Advise is one-of-a-kind, and while you definitely don't want to rely on it, sometimes there would be no other option and this system deserve praise for thinking about those cases.

Processes and Filters

For the last point here, I want to show off something that I've automated recently: AWS sign in. You can find the whole source code in my config here, but the relevant function is below.

(defun aws--login (role)
  "Internal login function --- handles the command as a process, and prompts for MFA."
  (let* ((process-name (format "%s-%s" aws-cli-auth-provider (replace-regexp-in-string "[/:]" "-" role)))
       (buffer (get-buffer-create (format "*%s*" process-name)))
       (prompt-regexp (rx (or "Enter verification code")))
       (prompt-sent nil))
    (with-current-buffer buffer
      (erase-buffer))

    (make-process
     :name process-name
     :buffer buffer
     :command (list aws-cli-auth-provider "login" "--force" "--skip-prompt" "--role" role)
     :filter
     (lambda (proc output)
       (with-current-buffer (process-buffer proc)
       (goto-char (point-max))
       (insert output)

       (unless prompt-sent
         (let ((buffer-contents (buffer-string)))
           (when (string-match-p prompt-regexp buffer-contents)
             (setq prompt-sent t)
             (let ((token (read-passwd "MFA token: ")))
               (process-send-string proc (concat token "\n"))))))))
     :sentinel
     (lambda (proc event)
       (when (string= "finished\n" event)
       (run-hooks 'aws-post-signin-hook))))))

Basically, I want to sign in to the AWS CLI for a specific role. This usually works great, however sometimes it might as for an MFA token, so if I run the login command with just shell-command it won't do anything if it hits that snag.

However, if I run the command as a process, well, you can easily wrap that prompt and have Emacs ask for the input in the minibuffer. That's what the filter is doing, it just checks if the process has sent text asking for a prompt and if it has, read that with read-passwd and send it to the process. When I was first thinking how to write this, I expected it to be much more annoying. But this is actually stupidly simple.

-1:-- Radical Builtins (Post Jakub Nowak)--L0--C0--2026-06-02T00:00:00.000Z

Sacha Chua: Transcript of chat with Matei Candea about Emacs and AI

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

Related links:

Expand for the transcript

NOTE Matei is an anthropologist; ethnographic research

What I actually do for work is to do ethnographic research, to interview people. I've written a lot about scientific communities.

For instance, I've written articles on behavioral scientists who work with animals and how they think about knowledge and technology and stuff. Completely independently of that, I kind of got into Emacs and got really excited. About four years later, I was, like, wait a minute, why don't I do an ethnography of Emacs as a community?

Sacha: Really cool people.

Matei: Right? Really cool people.

Curious about Emacs as a community in the time of AI

Matei: I think what I'm really saying is Emacs as a community in the time of AI and how that's shifting or not shifting how people are using it, and what it does. I've spoken to Prot on Monday. That was the first interview I did, and we had a great chat. I basically asked him how he got into Emacs and what it meant to him and what his relationship is to the community and stuff, and then a bit about AI and then a bit about what he feels are the interactions between the two.

Matei: That's, broadly speaking, what I would be interested in doing with you.

Matei: If you think there's a broader conversation, we could live stream and have an actual chat about how people use Emacs. By the way, I'm very happy also to tell you where my own trajectory was that I got into Emacs weirdly and randomly about a year before ChatGPT really hit the mainstream. The thing that you read by me was written because me and Ella together were trying to figure out Cambridge's response to AI as a university. Like, what are we going to do about it? If I'm going to be talking about that, I need to know how it works. But I don't want to use AI in my own actual work or in my teaching, because I think it's a bit dodgy. I don't really like it. Why don't I just do it with this kind of side project I've got, which is learning Emacs, right? And the weird paradoxical thing was that I now basically kind of live in Emacs. My email is mu4e. If you saw my screen now, the notes are basically a narrowed Org buffer with questions. Everything's email. But I don't think I could have got there that fast if it hadn't been for the fact that I started asking ChatGPT, like, "Oh, this isn't working. Can you just write me a defun that does this?" I'm not completely vibe coding. I'm trying to learn Elisp at the same time, but I'm in this weird position where... Anyway, this is why for me it raised these questions of: what does learning Emacs in the time of AI mean? As you can probably gather from the manifesto, I'm not pushing it at all. I'm really ambivalent about the use of AI. I find myself doing it and kind of sort of worrying about doing it. Would you be happy to do an interview like I did with Prot?

Sacha: Yeah, we can certainly do that. In addition to whatever I can share from my personal experiences, I think your interest in understanding and describing the community and the culture and how it's interacting with this AI thing, I think it'll offer a perspective that is different from what you usually see, because Emacs users have had this long tradition of fiddling with things and making it really malleable and fitting it to them and figuring this out in dialogue. It's figuring out in dialogue with themselves as they figure out their workflows, with the software as they learn from the code, with other people, with resources on the internet not necessarily attached to specific people. That's got a really long history. It's really interesting to see how AI both has plus sides and minus sides in this whole mix. It definitely, I think, will offer some insight that you won't hear with the frothy AI hype that other communities have. It's all very interesting.

Matei: Amazing. Let's start with a general kind of interview thing.

How did I first get into Emacs

Matei: How did you first get into Emacs?

Sacha: I was going through all the books in my university library about computer science. One of them was Unix Power Tools. I was like, there's this chapter on Emacs, and it mentions Tetris and other things. What is going on here? I tried it. It was great. I liked it. Then in fourth year or so, my screen stopped working. I didn't want to replace it. But there was Emacspeak. I was amazed. Lots of people had put together Emacspeak so I could use the computer with a broken screen. I could still read it periodically, if I tilted it and kind of looked at the low contrast thing… The speech synthesis worked just fine. I'm going to program this way.

Sacha: I'll plug into a monitor when I'm back in my room. But if I'm out and about, I have this other way to do it. Something that maybe most programs would not have anticipated, but because somebody had built it for themselves, it was something I could use. Before I got into Emacsspeak, I got into Planner Mode because I was a university student and I was taking notes. Planner Mode was an easy way for me to keep track of tasks. It was more flexible than other to-do managers.

Sacha: It's one of the packages that was popular before Org Mode. I started using that to write my blog. Blogs had just been invented around then. I was figuring out, how do I export RSS out of this? I was able to customize it to do that. I liked it so much I emailed John Wiegley, who had created Planner Mode. I said, hey, I can help you fix bugs. He said, great, you're the new maintainer now. Which was actually very good for me because I was a university student in the Philippines, and Philippines, and normally we don't get to work on anything really cool. Suddenly I was in this global community of people. There was a mailing list. People would send in questions or feature requests. I would share the things that I was working on. They were very, very patient with me. Like that one time, one of my changes accidentally deleted somebody's notes and they were still nice to me afterwards. The community has always been part of how I experience Emacs. Learning in public has also always been part of how I've been figuring out what I can do with it and changing it to fit my needs, as very idiosyncratic as they are sometimes... It has also always been part of my experience of Emacs.

Matei: When did this start?

Sacha: Very shortly after I started Emacs, I started blogging with it. My first blog post from that is 2001.

Matei: Right. You were studying computer science?

Sacha: I was studying computer science, yes.

Matei: Are you a computer scientist now? What do you do when you're not doing Emacs?

Sacha: Most of the time, I'm still focused on full-time parenting, which is why I'm going over to the freezer now to remember to put yogurt in the freezer. I do a tiny, tiny, tiny bit of consulting, but consulting, but for the last 10 years or so, I've just been focused on parenting. Playing with Emacs and being in touch with the Emacs community has been one of the ways that I've kind of kept sane. I've enjoyed the intellectual puzzles of: I have this thing that I want to do, how do I do it with code in ways that I can fit into five minutes here, ten minutes there of my life.

Matei: Do you do any other coding or just Elisp?

Sacha: JavaScript, Python on occasion. Some of my consulting involves making little JavaScript prototypes for ideas that my client has, but it's really just an hour a week, maybe less. But for fun, I still write a bit of JavaScript and Python. Emacs Lisp, however, is what I usually write because it's so much easier to do things when you've got the full editor with you.

Matei: Yes, that makes sense. I've got a million questions, but I'm going to try and do them in order. You've said a little bit about this already, but

What do you love about Emacs?

Matei: what do you love about Emacs?

Sacha: You can come up with a crazy idea and you can actually make it happen. So, for example, I've been doing a lot of conversations, interviewing people or working with my sister's interviews. I always like turning these into text because text is a lot more searchable. Chapters and things like that too, right, so that people can jump to just the part they're interested in. I don't know how other tools do it, but I love the fact that I can modify Org Mode so that I can capture timestamps. Wall-clock time is easier for me to work with. I can say, okay, while I'm typing, I just use an abbreviation to put in the timestamp that's the current time and my rough notes. I have another piece of code that translates that into offsets from the start of the video based on YouTube's live stream or the file name of the video. Then I can paste that into the subtitle file so that it automatically puts the chapters in roughly the right places. As I come up with little workflow ideas, I can actually implement them.

Community

Sacha: I also love the community of it. Looking through the blog posts or as I put together Emacs News every week, there's always all these interesting examples from people who are asking the same questions about about "What is it I want to do?" and "How can I do it 0.5% better?" They write these little functions. I'm like, oh, that is a fantastic idea. I get to absorb that into my life. Because I'm seeing it in the context of their blog post or their video, you get a glimpse of other people's lives as expressed through code, because all of the code is very personal. That is one of the things that is good about the fact that people are using AI sometimes to generate this code. They can make things that things that punch above their weight. A newcomer to Emacs can have customized functions that let you fully appreciate its power. But on the other hand, if the AI is just generating this code, you don't get a sense of like, where's the blog post this is coming from? Or who would I talk to to keep up with other crazy ideas they come up with? You're limited to just your ideas. Then there's the whole thing about license-washing. Most of the people release their code under GPL because it's Emacs, but the large language models never mention that. They never say, you also have the right to go and share this and modify this and build on top of it and contribute back to the community. Anyway, it doesn't feel right, the code. It doesn't quite get the conventions and the idioms yet. So the things that I love about Emacs are generally the fact that it can fit me like a glove and it's got this community of people who are also exploring what is possible as crazy as ideas sometimes get. There's always some way to hack it in.

Do you know how big the community is?

Matei:

Do you know how big the community is?

Sacha: I have no idea. We generally feel like it's a lot smaller than VS Code and probably a lot smaller than Vim. It depends, of course, on if you're talking about percentage, it depends also on... There's a lot of Clojure developers using it, because it's the standard Clojure way of doing things, but there are probably a lot fewer Java or JavaScript people using it because a lot of people are in VS Code instead. I used to do Google Analytics tracking on my website, but I stripped all of that out because cookies and tracking and all of that. When people ask me how many people read this stuff, I have no idea, but I do know that every time I look for Emacs News, I'm delighted by the breadth that I come across. To me, it feels like there's a thriving community that's large enough for my interests.

Matei: Cool. You're the second person I've actually spoken to. The first person was Protesilaos. I'm struck by the fact that from a sample of two, I've got two people who are not based in the US, who are super international, and also who are not developers.

Sacha: That is a fantastic thing about it. I love that we have researchers and sourdough bakers and knitters. Of course, the programming part is still there, but a lot of people end up getting into some kind of programming because of Emacs. Emacs is the only thing they ever code, and they don't even think of it as coding. It's just like, I do this, but I wanted to be able to do this, so I learned how to do Org Mode and source blocks, and that's all I can do, but it's great. I think that's really interesting because when you talk to people about their origin stories with Emacs… Sure, of course, you have the pockets of people who are like, I'm a computer science student and my professor said use this, so I'm using this, and so forth. But then you get these random high school music students who are like, oh, yeah, I just saw this video and I thought it looked really cool, so I taught myself how to do that. I don't know anybody else who uses it in real life, but I like it. Musicians using it live to do performance... Where are these people coming from? But they come across it, and it just strikes a chord with them, deep in their souls. It appeals to a certain tinkerer type, I guess. They just continue with it. They get stuck. Sometimes they leave and they come back, and all that stuff… But the breadth is one of my favorite things about Emacs.

Matei: Do you think that most of the people in the community are probably developers? Because when you were saying the community, you compared it to Vim and VS Code, which is to think of it really as an IDE kind of thing.

Sacha: That's usually what people talk about, right? Because usually when people are thinking, how popular is this, they're stacking it up against developer tools because those are the surveys that the development websites do. Stack Overflow or State of Clojure or whatever. They'll ask people, “What editor do you use?” But given Emacs' surprising popularity among people who are, for example, diagnosed with ADHD and find that Org Mode is the only way they can manage their brains…

Matei: Is that a thing? That's really interesting.

Sacha: In a number of Reddit threads that I've seen, people are like, yeah, I'm not a programmer, but Org Mode is the only way that I've figured out how to manage my brain. Or people will come to Emacs from something else specifically for Org Mode because of the way that it can help them manage their tasks or agenda, because they can sculpt it to fit what their specific workflow could be. It's amazing. Of course, we've got the writers and the researchers who are like, "I love publishing beautifully typeset things, but I don't like working with LaTeX all that much, so let me just figure out the template once."

Matei: Yeah, totally. I really came to Emacs because I was looking for an outliner. I'd been writing in Markdown for a while. I was really getting sick of the heavy Word stuff. And I was, like, Org Mode, omg, it's amazing! Then from there, I was bitten.

Do you have any frustrations with Emacs?

Matei:

Do you have any frustrations with Emacs?

Sacha: I would like to have more time in the day to fiddle with things. In terms of the balance between fiddling with my config and doing the thing that I want to do, if I sandwich it so that I do my 5 to 15 minutes of Emacs fiddling at the start, then I'm motivated to go through the task because I want to test that my improvement works. Then it becomes a good balance for me. I don't spend all the time feeling like I'm yak shaving, and I don't spend the time struggling with workflow because I didn't take the time to automate it.

Sacha: I would like to have more time, because I always come up with more ideas in the middle of something. "I know this is possible. I just have to sit down and do it, and it'll be great. But okay, I have to wait till my next 5 to 15 minute window where I can fiddle with it again." The other thing that I've been trying to figure out is: how do you help people develop that intuition for how to do things, how to make Emacs do things? We see a lot of people come into the community. They might get stuck on some things. The tutorial is very useful, but it can be overwhelming. The whole Emacs thing can be very overwhelming for people. How you help people get through that part is something that's of great interest to me. Bringing it back to AI and large language models, the fact that people can sometimes have a conversation with this endlessly patient tutor where they might be too embarrassed to ask their questions on a mailing list or a forum, I think that's fantastic. But also, going to your manifesto's points about learning by doing and education and the eureka moment, we also don't want this quick and easy help to rob people of the understanding that they get from looking at it and tweaking the code or learning how to read through the source code themselves. There's just so much there that I would hate for people to just get stuck in the “please generate this code for me" level rather than be able to learn this is how I start learning from other people's source code so that I can come up with more ideas.

Matei: That's right. That's also what I think basically. Here's an interesting question.

Would you ever leave Emacs?

Matei:

Would you ever leave Emacs?

Sacha: I cannot imagine an editor at the moment that would let me get away with nearly half of the things that I do, but maybe even less. Right now, I've got so many odd little customizations for it. For example, on my phone, I'll use Orgzly Revived to capture a quick note so that I can go back into Emacs later and do it. But even though I'm comfortable programming in JavaScript and Python, and there are lots of tools available there, the interactive interface part of things is something that I don't see any other program give me the same kind of platform of support or building blocks to play with. Who knows? If some day, this thing manages to support all of my hacks built on hacks and gives me that same kind of feedback loop, but it's also multithreaded and graphical and whatever, I might give it a try. But at the moment since I can get away with so much in Emacs and I know that people behind the scenes are working on adding even more to it, it's okay, long term. It's been around for 40 years. It'll be around for... Probably it'll outlive me. I don't have to worry too much about giving up on it.

How important for you is the free software bit of Emacs?

Matei:

How important for you is the free software bit of Emacs?

I was on Mac when I got into Emacs. I went to GNU Emacs to download it and it said, we made this available to people on proprietary systems in order to teach you to free yourself. I was like, huh? I downloaded it and I'm now running Arch Linux. It definitely worked. Richard Stallman has downloaded himself into my brain. How much is the free software bit of it important to you in using Emacs?

Sacha: I'm not a purist. I will happily be the interface using the non-free things. For example, when we were doing EmacsConf, the first few years before Whisper was around, I was the one doing like, okay, fine, YouTube has this subtitling thing that we can grab the stuff from. Yeah, it's a non-free service, but I will happily take advantage of it in order to make the information more free, and things like that. I use both free and non-free things, but I love the single-minded focus that a lot of people have on freedom and making sure that other people enjoy these rights. For example, in the Emacs community, a surprising number refuse to use JavaScript because a lot of JavaScript is non-free software. I want to make sure that my website still makes sense without JavaScript. EmacsConf, there are ways to participate even participate even without JavaScript. You can use MPV to watch the stream. It's all free software. You can use IRC to chat. All that stuff is very important to people, and that's great. I love the fact that for a lot of people, they really care about making sure other people can continue to enjoy these freedoms to modify things and to build on it. Every so often someone comes into the Emacs community and they're like, oh yeah, I want to make money making packages here. I'm going to put my package behind a paywall. You've got to send me a donation in order to use it. Then they get smacked down so hard. Usually the way it works is someone will then, you know, take a look at their README and say, okay, that looks vibe-coded. I can do it faster and I'll do it for free. That's the usual response to this stuff. Yeah, here's the thing that you're trying to sell, but it's free.

Matei: So that never works. I was struck by this. It seems to be so absolutely immune to takeover by proprietary stuff.

Sacha: I mean, it's a startup hustle mentality in other communities, but in Emacs, it does not fly. Mostly because people are, like, are, like, I know the tools you're using, I can do that better myself. There are people who do get sustained by donations from Emacs community members, but it generally is more of a "I appreciate your work and I will send you this voluntary donation" instead of your paywalling your stuff behind this thing, which feels very much against the ethos of the Emacs community. It's been interesting to see the AI hustle "software as a service or product type" thing try to infiltrate the Emacs community, and they are having none of it.

Matei: Interesting. Why do you think it's so resilient to that?

Sacha: Because we've had such a long tradition of sharing things for free, building on top of things that people have freely shared: not just like free as in beer, but free as in you've got the source code, you've got all the rights to do whatever you want with it, including for free. That's baked into the community. Any time someone comes in and tries to say, oh yeah, I've got this commercial packaging of Emacs, it's all rights reserved, people are like, yeah, there's probably a GPL violation right there, so let's go.

Matei: Cool.

How do you explain your passion for Emacs to non-Emacs users?

Matei: How do you explain your passion for Emacs to non-Emacs users?

Sacha: I don't usually. I love the fact that I can tinker with it, right? If it clicks for people, it clicks. But if it doesn't click for people and they don't necessarily want or need that, then it's okay for them to use something else. I love the fact that people are using or even shifting to other editors. For example, we've had a couple of people announce that they're leaving Emacs recently because vibe coding has made it possible for them to build native applications and they don't have to build it on top of Emacs anymore. They can finally get their Vim config set up the way that they wanted to because the LLM can generate that stuff for them. Whereas in Emacs, it would have been a lot easier to write it themselves, but now they can do it with VS Code or whatever. It's great because the more people are experimenting with interesting ideas, even outside Emacs, the more we get to steal those ideas and then bring them back. You see a lot of this sometimes. You see people re-implementing cool ideas from other editors or other tools. To me, it's totally okay if other people use something else, especially if they tell me the cool stuff that they think only that editor can do. Because I'm like, that sounds like an interesting feature. Do tell me more. There was an interesting talk by Jeremy Friesen in either last EmacsConf or the one before that, about mentoring and how he's no longer trying to push people to use Emacs. He wants to share the general workflow practices he's using. If he's pair programming

Sacha: with someone, he might say, how do you jump to a specific function definition? They might show him something, or they might realize that's a thing. I can go look in my editor how to do that. He might show, this is how I do it. That's the general idea. Sometimes when people start talking workflow, then talking workflow, then talking workflow, then people who are not using Emacs will go, "That looks really cool. How do I do that?" Then that?" Then you send them down the path of: get it installed, go through the tutorial, that sort of stuff. But it always helps to have that specific reason, the thing that they want to be able to do. For me, for example, I love the way that Org Mode lets me have my notes and the code and the links. It's all one big thing. I don't have to think about, oh, okay, I have to do everything in Python because that's what Jupyter does. I can do some of it in Emacs Lisp, and I can do some of it in shell scripts, and I can do some of it in JavaScript or Python. It's like all this big mess Org Babel kind of thing. Yeah, because your brain might not be in tune with all those different languages, but it works for me. If other people see that and they say, I want to do that too, then that's when you help them get into Emacs. But aside from that, I don't talk to people in elevators and say, have you heard the good news?

Matei: I was wondering even more broadly than kind of people who are already coding with a different editor. To tell you a story... My cousin is also an anthropologist. He's an anthropologist in France. I've known for years that he was into Linux and free software and stuff. When I got into Emacs, he said, you know I've been doing Emacs for 10 years. I was like, what? How? What? And he'd never told me. I realize now, having been doing Emacs for four years, I can't talk to my colleagues and friends about it because they look over my shoulder and it's like, what are you doing? This looks like it's from the 1980s. Even trying to explain to people what Emacs is... I don't mean coders, I just mean people. My cousin said, yeah, I talk to people about free software all the time. I've never talked to anyone about Emacs. It's just so weird.

Sacha: I think that's why the community is so important, right? I aggregate a lot of blogs on Planet Emacslife so people can bump into each other. There are a lot of meetups, some of which we host on BigBlueButton... There are meetups, by the way. If you check under Emacs News, there's actually a very active London meetup.

Matei: I haven't yet.

To what extent do people meet in person with Emacs?

Matei: To what extent do people meet in person with Emacs?

Sacha: Apparently, a lot of people meet in person whenever they're lucky enough to get a sense that there are actually other people in their general geographic location who are interested in this. But there are also a lot of people who meet online. Org Meetup has a meetup every month that has about 20 people in it.

Sacha: Emacs Berlin has a meetup that's hybrid, and so it's both in person and online. There's Emacs Asia Pacific. There's a whole list of meetups in Emacs News, which is that newsletter that I do every week. I list upcoming events, and there's also a link there to the calendar as well as to the user groups page which lists by region. There are a lot of people getting together about Emacs because a lot of times, you learn about Emacs by looking over someone's shoulder, physical or virtual, right? This is how you learn about things that you would not have even thought of asking an AI about. They're doing a demonstration or they're doing a video, and you're like, what is that thing that you just did? They had no plans to talk about it because it's just something they take for granted. It's a keyword shortcut or a command. It's just part of the workflow. They don't think about it anymore. Or it's even as simple as "What's that theme? What's that font?" Because people can see it, can see somebody doing stuff with Emacs, they get inspired to learn more and to adopt that into their workflow. That is one of the things that I love about how people learn Emacs. It's very convivial, right?

Matei: Yeah.

Learning in public

Matei: You said the phrase earlier: learning in public. In one sense, that sounds scary. Learning in public, making mistakes in public and stuff. You said it as a really good thing. Tell me more about learning in public.

Sacha: My favorite kinds of blog posts is

Sacha: when I'm proud of myself for figuring out something clever. Like, okay, here's this function function to do this thing. I had to figure it out. It was hard. It took like a day or two to do it. Then someone comes by in the comments and says, oh yeah, that's built in.

Matei: Yeah, I've been there.

Sacha: "You just change this variable." It happens so often. The reason is because Emacs is so big, right? There are variables and functions that I would not think of coming across. Maybe I'm not using the right words to search for them, or whatever. If you add to that the entire package ecosystem and as well as the things that are not people's packaged code, snippets in people's config and whatnot... Chances are someone has come across the same problem that I'm thinking about and has come up with a more elegant solution for it. If I'm not using the same words, I might not find it. One of the things that I like about large language models is that even if I use my words, sometimes it will suggest something that does that translation, right? It's an approximate search. But even if I don't have that, if I'm writing about something, then I have that opportunity for somebody to say, oh yeah, you should check this out. Or several years later, someone might also say, that is exactly what I was trying to do. I'm taking your code. I've built something on top of it to make it even better. For me, writing about what I'm learning

Sacha: with Emacs is a great way to learn even more from the community. I keep trying to convince people, yes, please, even if you're a beginner, write about what you're learning, because it's a great way to crystallize that knowledge for yourself, become part of the community and part of the conversations, and learn about things that you would not have thought of asking about.

Matei: Well, I'm following your example. I'm trying to write my config in Org Babel at the moment, partly as a way to say, wait a minute, what is this thing? How does it work? It's so useful. But one thing I was wondering, and it's partly also just a practical question,

Disclaimers

Matei: I've never tried to contribute or to post

Matei: anything on anything, partly because I worry that my stuff is crap.

Sacha: If you put a disclaimer, that way they know they're reading it for the idea, but not necessarily the Emacs Lisp style. That's fine with me too. There are a lot of people who are like, you know, it's got too many emojis in it, I'm not going to read that. I'm going to focus my time reading something else that's been handcrafted and all that stuff. That's fine too. There's room for all sorts of people and all sorts of approaches to this. Sometimes even just the idea of something is already valuable, that somebody thought of saying, hey, my workflow would be better if it could just do this. If there's a screenshot, even better, right? You can see how it works. Screenshot or video or animated GIF. Because then they can go and write the code that they would have to do anyway. Because of course, they've got their own personalized setup. You know, the code that you write will not mesh perfectly with their particular setup. There's this whole… There's this Lisp curse essay that's sort of related to…

Matei: I was going to ask you about that.

Sacha: We've all got our ecosystems of our own code and absorbing something into it is sometimes hard. But if you start with even just the idea that somebody else has written about, whether or not you take their actual code for it or use their code as a building block, that is already useful and interesting. Again, you don't have to be Bozhidar Batsov or Omar Antolin to be able to contribute at that level. Even at the beginner level, you could just be like, I just need to do this thing and it's driving me crazy to do it manually all the time. Then I'm like, you can do that non-manually? Oh yeah, we should do that.

Matei: Cool. Just to come back to the question about talking to other people about Emacs, do you ever talk to people who are not programmers?

Do you ever talk to family and friends about Emacs?

Matei: Do you ever talk to family and friends about Emacs? Do you ever have to explain what this thing is that you're doing or do you just not?

Sacha: Well, my kiddo is 10, and she's like, can you set me up a kid Emacs? Because she sees me like... Yes! Clearly something of great interest to me. I said, maybe. She does a little bit of vibe coding with Claude as she generates interactive stories. She was trying to track down a syntax error at some point. I was like, can I just install Emacs on your computer so I can do... And she said no. My husband uses Vim.

Sacha: Although he did get very interested in Org Mode at some point, so he found the appropriate Vim plug-in for it. That was amusing. I don't talk to people about editor choices. I just do the stuff that I do. When I write about it, sometimes people will come across it, again, coming from completely different backgrounds. They'll be like, oh yeah, I also need to edit transcripts. What is this Emacs thing? And I'm like, well, it's a very long road, but it's a lot of fun and it's worth it. If you do want to get into it, here's some ways to get started. I don't know. But you can look at the videos first to see whether it might be something that resonates with you.

Matei: Yeah. No, I'm the same. I'm very cautious. I've seen that. The learning curve thing is so cool. My kids are like, your computer used to be so pretty when it was a Mac and now it just looks really ugly. I'm like, oh, if you knew. It's so much more beautiful now, but never mind. Cool. We've talked a lot about AI actually already.

Do you ever use AI in chatbots for anything else?

Matei: Do you ever use AI in chatbots for anything else?

Sacha: Well, I'm learning French at the moment. In this case, the kind of the regression to the mean that AI does is very useful for me because I need to know, what is the common word choice here? How do I get the grammar to do the thing? I don't really want to spend an hour of a relatively expensive tutor's time picking apart my subject-verb agreement or my nouns agreeing in plurality with the verbs and stuff like that. It's reasonably acceptable to use large language models for language feedback. That makes sense. In terms of coding, I'm not there yet. Quite a few people are very enthusiastic about it. Even in Emacs, some people are like, "I don't write my code anymore. I just vibe the whole thing." I love the way that it gets a lot of people to make things that they would not otherwise have the time or effort or experience to do, but on the other hand also, it hallucinates a lot of things. It gets me excited: oh there's a variable or function specifically for this? No! It doesn't exist. I can make it exist, so it's a little less frustrating for me, because I can say, you know, that does make sense. I can write that. I can fill in the blanks for it. But 9 times out of 10, I'll be like, no, no, go back and do the proper search. One out of 10 times, it'll tell me, oh yeah, there is this function and it will exist, exist, then I'm like, okay, great, I want to use that, because I wouldn't have otherwise come across it. But I cannot use it to generate a lot of code because I get this urge to just rewrite things to fit the way I want. I just use it like… it suggests ideas. It acts kind of like a search engine that gets things wrong most of the time. I'll just take the interesting parts of that and do it myself. Aside from that, I haven't really dug into it to the extent that other people have. I am happy to take a step back and see how this all shakes out because with the shake-up in pricing and all the externalized costs that are slowly being factored in, I'm not going to build a house of cards on it.

Matei: Yeah, that's very wise, I think. How do you feel about the fact that these models have been trained on all these free conversations? They just suck up all this stuff that people have been doing for 40 years. Is that a problem in and of itself?

Sacha: It's interesting in the particular case of Emacs. As I mentioned, the vast majority of Emacs Lisp is released under either the GPL or the MIT license or even public domain because people in Emacs really care about sharing stuff and they want other people to do it. It's not like, oh, we've got this proprietary code and it's been stolen away from us, it's us, it's not available for other people. The fact that we're treating AI-generated code as non-copyrightable, it's okay that it's sort of out there. It would be nice to be able to say, hey, this stuff is GPL, so if you're going to build on it, please share it under the same licenses. But in terms of the way that many people use it for personal configuration and learning, I'm okay with that. I know that other people in the community have stronger stances, and that's also okay. Because there's no attribution, there's no link back to the person. The licensing doesn't require [lots of] attribution. You don't have to say, oh yeah, this config was inspired by these people and at these links. You don't have to do that, but it would be nice to be able to follow those links back to the people. That would be nice. The ability for more people to learn from this stuff is good. If we can encourage them to share what they're figuring out with other people, that's also good.

Matei: So is the problem less about kind of taking intellectual property and more about

Not breaking connections to people

Matei: breaking connections to people or like breaking these traceable connections to other people in the community?

Sacha: That's the part that I'm interested in and care about, because I feel the community experience of Emacs is very interesting. All the other stuff, there are people who are far smarter than me and have focused on... This is above my pay grade, right? Actually working out intellectual property, what that means. A lot of people think about copyright and copyleft and that stuff. I will leave that to them to sort all of the ethics after that one. I just care about making sure people can feel like they're learning, feel like they're welcome, and can find the ways forward both with assistance of large language models if they want to, but also connecting with real people who they can learn from too.

Matei: Yeah, super. I think that's sort of the questions I had, really. I'm sure I'm going to have a million other questions. I might email you back about this. Did you have any questions for me?

Education and ethics and eureka

Sacha: I love now knowing that you were writing your manifesto with that experience of being an Emacs user in mind, because the way that the education and ethics and eureka was like, that actually lines up precisely with the Emacs community and what it's like and what we care about. I would love to explore this in future conversations and see how we can help people navigate this time. There's a lot of froth about AI, and the business world is losing their heads over this collectively. The programmers in industry either find it useful but also, in general, seem to have a fairly worse experience. This is not where we should be using this. This is not how this is supposed to be turning out. It should not be leading to more unhappiness, but it is. It would be interesting to sort out both in the society level, but also in the individual level, as people make their own choices about what to use and how much to use it for, and also the impact, even if they're not making those choices themselves. I think the general sense now, for at least Emacs and Org Mode, is "we're not going to accept LLM-generated contributions because we've got to have a person who can stand behind the code." We so far have been safe from the inundation of generated pull requests that are plaguing other open source projects. It's definitely something to watch out for. But there is some tension. People are proud of their vibe-coded projects, but on the other hand, people are like, well, it takes 5 minutes or 15 minutes to generate this, and because it's not really maintainable, people will lose interest in it after their 15 minutes of fame on Reddit with their nice screenshots and all that. It's not going to keep moving forward.

Matei: Is that kind of like a… version of the Curse of Lisp written large? Everyone's just going to write their own programs at home and no one's going to be talking to each other anymore.

Sacha: It is very similar to that. that. It can be a problem. It can be an opportunity. It's not one or the other yet. We're figuring out as a community and as individuals how to navigate this. We have this long history of people not actually being able to adopt to adopt someone else's code off the shelf. It's amazing when someone actually puts together a package that can cut across a large variety of use cases. It takes a lot of work to get there, but things like Magit and Org Mode, how do these things happen? Yeah, it's fantastic. I love the fact that we can look at things

Sacha: like consult and vertico... The fact that they can work for a lot of people is amazing. It's actually pretty rare in the Emacs community. But for the most part, we are in our little fiefdoms and we have to make an effort to do that kind of connection. Whether or not the other person is using vibe-coded code doesn't matter that much. There's still that barrier. Higher barrier if you're dealing with vibe code because they don't understand it and you don't understand it and the code is hard to read. The ideas can be transmitted over blog posts and videos. But at the same time, the fact that more people like you can use this to start to experience the power of Emacs, the customizability of it, and can then go on to imagine, hey, is this what software could be? Can it be personal? Can it be malleable? Can I say, "No company is going to anticipate this particular need, but I can make it for myself."? I think that's really worth it. If the tools will help us get there, and if we can find our own balance of ethics that are okay with this... Some people might say, no, definitely not for me, even if it gives me the power. Some people were like, I just want to get this stuff working. That's cool, too. We get to see how that all works out.

Matei: It's interesting. I've written this paper for which I gave a talk in Oxford a couple of weeks ago about this, really for anthropologists. It's anthropologists. It's very interesting that a lot of the things we were talking about today, I thought that might be the case on some of these things. It's partly thinking about the way in which AI, ChatGPT, whatever, kind of interferes, becomes like a broker between the community and the individual. So the good side of it is that you're never going to be told to go and read the manual, right? It's always going to say, "Yeah, sure, that's great." But the bad thing is, you're never going to go and read the manual. That's the problem, right? But what I said at the end of it and I don't know whether this resonates at all, but I said now that I'm becoming aware that this is a problem, the paradox that I got into Emacs for the community and yet, in a way, I'm being moved away from the community. Increasingly, now, I will ask not "write this code for me" but "explain to me why this code doesn't work" or "explain to me why my problem could be done differently," and even more than that, not even "explain to me this" but "suggest to me how I could post this on a forum." I'm a bit worried about posting on a forum in case someone turns around and says, that's stupid. Claude or someone can say, if you write it like that, some people might find it interesting. Does that feel like a different kind of use of AI maybe?

Sacha: It does, and I encourage the more reflective use of it. For example, you might say, instead of generating this code, you might say, can you help me figure out what it is that I actually want to have in my workflow? Can you ask me questions to help me figure out how to do this or how to break it down into smaller tasks? Then that might be a more useful way of doing it. Sometimes people respond better when something is asking them questions. That is possibly an interesting use of AI.

Matei: Amazing. Sacha, thank you so much for your time.

Future conversations

Matei: Having had this conversation, do you think there's matter here for some kind of live stream or something, maybe with other people who want to talk about this stuff?

Sacha: In fact, if you wanted to take this recording and plop it somewhere public, I am totally fine with that. Learning out loud is how we have these conversations grow, right? The conversation is like this brain dump of ideas, and if we want to start unpacking those ideas and exploring them through all the multifaceted perspectives that we have in the Emacs community, other anthropologists or people who are interested in the philosophy of it, there's people who have so much deep experience in things that I have no idea. I would love for them to be able to say, let's take this facet of this conversation and build on it and explore that one. I am totally okay with both sharing this conversation, if you want to, as well as having other conversations that other people might be able to ripple out from.

Matei: Fantastic. I mentioned to Protesilaos that we're going to have this chat, and he said, you know, if you want to at some point organize a discussion over this kind of stuff, he'd be very happy to be involved.

Sacha: I've been experimenting with making myself ask people for help. Prot has coaching sessions. If our schedules can line up, then I can schedule a three-way conversation. It can be live and we can build on the ideas that you might have or follow-up questions that you might have, and then we can see if other people do as well. So that could be good. I'm looking forward to hearing about your insights. I would love to see where this goes. I think the Emacs community is definitely worth studying. I think that there are insights here that you might not otherwise come across in more specialized, more focused... Like, just developers or whatever, or more focused on closed source. There's something interesting about this mix of Emacs and AI and plain text and all that stuff. I would love to see where this goes.

Matei: Amazing. Thank you very much.

Sacha: All right. Bye.

Matei: Bye.

If you want to chat about Emacs and AI, you can e-mail Matei or check out Matei Candea | Anthropology.

View Org source for this post

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

-1:-- Transcript of chat with Matei Candea about Emacs and AI (Post Sacha Chua)--L0--C0--2026-06-01T19:28:55.000Z

Irreal: My Growing Appreciation For EWW

A couple of weeks ago, I wrote about using EWW to avoid paywalls and my experiments to see if it really worked. As I reported, it did in a surprising number of cases. But as I also wrote, I’m not that interested in avoiding paywalls so I didn’t expect to get much out of the experiment other than satisfying my idle curiosity.

It turns out though that I discovered using EWW could be very restful. As I wrote in that last post,

The other thing I learned is that reading content with EWW can be a very restful experience. No ads, no blinkenlights, and sometimes, no paywall either. I didn’t try running EWW with eww-readable but that would probably make the experience even more restful.

My normal procedure is to read my feeds with Elfeed—the world’s best RSS reader—and to display the original Web page in the same buffer with elfeed-webkit. That gives me a browser like view of the page. The problem is, my ad blocker doesn’t work with elfeed-webkit so I get all the trash and abuse one gets with a default page load1.

During my experiment I discovered that calling EWW when a site gets out of control is an excellent solution. The latest version of elfeed makes this easy so if I site becomes too obnoxious, I simply switch to EWW and invoke eww-readable with R to provide a quiet and restful wall of text (complete with the accompanying pictures).

It’s amazing how much junk we just take for granted when all we want to do is read an article or post. EWW takes away a lot of the sting. No, it’s still not going to replace the browser but it’s an excellent companion to it.

Footnotes:

1

John Gruber has an excellent screed on one part of this default behavior. There are plenty of others.

-1:-- My Growing Appreciation For EWW (Post Irreal)--L0--C0--2026-06-01T15:13:44.000Z

Amin Bandali: Free software activities in May 2026

Hello and welcome to my May 2026 free software activities report. A lot's been going on in my life offline so I took a bit of a hiatus from doing these reports, but I've had a fairly productive month of May so I thought it'd be nice to do another one for this month.

GNU & FSF

  • GNU Emacs:
    • ffs-0.2.2: I finally polished and published my ffs package for GNU Emacs on GNU ELPA. Many thanks to Protesilaos for rounds of code review and feedback for improving and polishing the package in preparation for submission to GNU ELPA.
    • bug#81101: Trying to visit https://www.emacswiki.org in EWW I noticed it fails with a Somebody wants you to give them money error due to the anti-bot challenge being served with a HTTP 402 (Payment Required) response. So I landed a patch 12eec781ed6 to no longer do that. Thanks to Emacs comaintainer Sean Whitton for reviewing and approving my proposed patch.
    • bug#81107: I noticed that in EWW, unlike <input type="submit"> HTML buttons, <button> elements were not tab-stoppable, leading to poorer usability and accessibility. So I landed a patch ec3d662de0b to fix that. Thanks to Emacs comaintainer Eli Zaretskii for reviewing, providing feedback, and accepting my proposed change.
    • Emacs Chat with Sacha Chua: I joined Sacha for a new episode of her Emacs Chat podcast, where we talked about Emacs and life. I gave a quick tour of my Emacs configuration, discussing at length my configurations for EXWM (Emacs X Window Manager) among other topics like Emacs's facility for visually indicating buffer boundaries in the fringe by setting indicate-buffer-boundaries and my convenience configuration macros.
  • maintainers@: I started the next long-overdue round of emails to GNU package maintainers to confirm the contact information we have on file for them and get a brief status update about their packages. Emails are sent in small batches to keep the workload of handling the responses manageable for assistant GNUisances.
  • GNU Spotlight: I prepared and sent the May GNU Spotlight to the FSF campaigns team for publication on the FSF's community blog and the monthly Free Software Supporter newsletter.

Debian

I've begun the work toward updating the Jami package in Debian unstable again, which means I need to package new releases of its direct and indirect dependencies. For OpenDHT, I need to update RESTinio, and to do that I first need to package expected-lite and sobjectizer for Debian:

  • #1120837: ITP: expected-lite – expected objects for C++11 and later
  • #1137609: ITP: sobjectizer – C++ implementation of Actor, Publish-Subscribe, and CSP models

I've been working on packaging both and hope to have them uploaded to the archive in the next days and weeks.

That's it for this month's report.

Take care, and so long for now.

-1:-- Free software activities in May 2026 (Post Amin Bandali)--L0--C0--2026-06-01T02:30:00.000Z

Tim Heaney: Ziglings

I just completed Ziglings! It's wicked fun! Zig is a programming language and Ziglings is a collection of fun exercises to help you learn it. I heard about if from this interview with Andrew Kelley. He is the creator of Zig (but not the creator of Ziglings, that's Dave Gauer). Zig is still under development (it has yet to release version 1.0), so it's changing a lot and Ziglings is changing right along with it.
-1:-- Ziglings (Post Tim Heaney)--L0--C0--2026-06-01T00:00:00.000Z

TAONAW - Emacs and Org Mode: Installing Harper on Kubuntu: The Right Way. Maybe.

I recently installed Harper on my Linux Desktop to work with Emacs, but since I’m running Kubuntu, I ran into difficulties. In short, there’s no Flatpak or Apt option when it comes to Harper.

After a few interesting changes to the way I journal in Emacs (this is something I hope to discuss soon), I decided to go for the full version, and that meant installing Rust and Cargo.

This was another “programming quest” I didn’t know how to start in the past. I used Claude.ai to guide me, but as usual, I asked a million questions about everything, so I can explain it again here (this is my test to myself). So if you’re new to all of this like I am, take the explanations with a grain of salt, and if you’re an experienced developer who understands Rust (and curl, for that matter) feel free to reach out and educate me further.

Alright, here we go:

To install Rust and Cargo with it:

    curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

The above is a bit more complex than what’s in Cargo’s documentation, but based on a quick search, it is what’s directly recommended in rustup, which is where you install Rust. The idea is the same as other curl installations, with a few more options for added security and to ensure we’re getting what we really want:

Run curl, but restrict it only to https (no http):

curl --proto '=https'

Somewhat redundant: curl will usually refuse anything lower than 1.2 by default. This forces TLS 1.2 as the minimum. This is good practice and also what they tell us to use, so why not:

--tlsv1.2

options for silent mode s (so don’t show us progress and status), but show us if we get errors S, and if we get a 404 error or similar, just stop silently f (otherwise it will pipe it into the sh command at the end):

-sSf

Then we have the URL to download from:

https://sh.rustup.rs

and finally we pipe it | into a shell sh command so it runs as a script as intended here. If you go to the above URL directly, it will download a shell script - so this is how we get it and run it in one go:

| sh

Because we’re about to run commands for Rust, it’s a good idea to add it to our source environment, the same as editing ~/.bashrc manually and adding . "$HOME/.cargo/env". Without it, we’ll have to specify where Cargo is installed for the next commands

    source ~/.bashrc

At first, I installed what was available on crates.io. Crates, as I learned, is the official repository for Cargo, our “app store” for Rust, (or Elpa for Emacs). The individual packages are called “crates”. Makes sense now, but before it all looked like a bunch of command-line voodoo to me.

However, apperently what’s available on Crates is not up to snuff. The official repository for Harper is at https://github.com/Automattic/harper, and it specifies version 2.3.1, whereas the one available in Crates is 2.0.0. We are still using cargo (it’s the “installer” for Rust), but specify to get what we need directly from there:

    cargo install --git https://github.com/Automattic/harper harper-ls --locked

The git option tells Cargo we’re installing directly with git, which is what we’re doing here; the locked option is specified in Harper’s documentation, and upon some research, I learned this forces the exact dependency versions specified in Cargo.lock. Without it, cargo might choose newer dependency versions that were not tested or are not specified in the documentation.

Finally, in Emacs, we want to tell eglot where to find Harper:

    (when (eq system-type 'gnu/linux)
      (add-to-list 'exec-path (expand-file-name "~/.cargo/bin")))

In my case, since I use the same config on my Mac, I want this to run only on Linux. On my Mac, Harper is installed without all these shenanigans directly from Homebrew, which also keeps it up to date. This is added to the same config block I specified in my earlier post. It now looks like this:

            (with-eval-after-load 'eglot
              (add-to-list 'eglot-server-programs
                           '(org-mode . ("harper-ls" "--stdio"))))
    
             (setq-default eglot-workspace-configuration
                        '(:harper-ls (:dialect "American" :linters (:LongSentences :json-false :AvoidCurses :json-false))))

      ;; Besides choosing American as the language, I also want to ignore long sentences (the main issue is that it hides other errors nested in those), and I also want Harper not to tell me when it thinks something is offensive. I'm a big boy/an old fart. The full list of these options is in https://writewithharper.com/docs/rules. It needs to be nested inside the :linters option.
    
    (when (eq system-type 'gnu/linux)
      (add-to-list 'exec-path (expand-file-name "~/.cargo/bin")))

In the future, when I need to update:

    cargo install --git https://github.com/Automattic/harper harper-ls --locked

Now, Harper works as it should on my Linux Desktop. Another geeky weekend project.

-1:-- Installing Harper on Kubuntu: The Right Way. Maybe. (Post TAONAW - Emacs and Org Mode)--L0--C0--2026-05-31T22:41:31.000Z

Mike Zamansky: Giant - Antisemitism, antizionism, and Roald Dahl

https://upload.wikimedia.org/wikipedia/en/5/57/GiantPlayPoster.png
Giant

This past Friday, I had the chance to see "Giant," the play written by Mark Rosenblatt. A few friends asked for my take on social media so I thought I'd write my thoughts up here.

So, if you're looking for the usual CS Ed or Emacs material, feel free to skip this one. On the other hand, I'd encourage you to read on anyway.

First and foremost, the play was fantastic. John Lithgow was fantastic and Ava Cash was his match. The rest of the cast was solid overall and I could hear thoughtful discussion around me during the intermission and I personally wanted to let everything stew for a couple of days before writing this.

If you're in NYC and have a chance - see this play.

In 1983, children's author Roald Dahl wrote a review of the picture book "God Cried." In it, he wrote a number of antisemitic slurs. The play is a fictionalized account of an afternoon at Dahl's new house (under construction) where he met with publishers. The topic was what, if anything should be done about the review, the ensuing push back and the fact that Dahl's latest book "The Witches" as due to be published soon after.

To fully paint the context here, Dahl was, by his own admission an antisemite and we'll get to a bit of that later. He also publicly released antisemitic statements after the original review that set the stage for this play. In fact, the play closes quoting some of those statements via a call between Dahl and a reporter. In 2020, his family released an apology.

Even though the play first ran after the October 7 attacks, it was finalized prior and to my knowledge unchanged as a results of the attacks or the ensuing war.

The cast:

Roald Dahl
John Lithgow
Filicity Crosland
Rachael Stirling - Dahl's mistress, fiance, and later wife.
Tom Maschler
Elliot Levey - Executive at Dahl's publishing company. England based. A Jew who's family fled Vienna after Nazi annexation when he was five.
Jessie Stone
Aya Cash - Sales employee of Dahl's publishing company. Also Jewish. Based in America.
Hallie
Stella Everett - Domestic employee of the Dahl's
Wally Suanders
David Manis - Groundskeeper for the Dahl's.

While the meeting depicted in the play was fictional, Dahl, Crosland, and Maschler did indeed exist though I have no idea if Crosland or Maschler's depictions were in any was based in their real personalities. Stone was created for the play and I'm not sure about the last two.

In the early stages, Maschler and Stone are trying to convince Dahl to publish a statement - an apology for his comments and Dahl refuses. Maschler, in spite of being a holocaust survivor, is playing the role of the "good Jew" - he said he was just "put on a train" that he was a child. He's assimilated and seems to want to "go along to get along." His concern is all about Dahl's reputation and selling book. The antisemitism doesn't phase him in the least.

Stone on the other hand, an American Jew, sees things differently. While initially towing the line she can't contain herself and calls it like she see it. At the end of the first act, Stone quotes from Dahl's review emphasizing where he calls out Israel's actions but refers to them as the actions of an entire race not of individuals nor a specific government. It was a powerful scene and what likely led to a lot of the intermission discussion in the audience.

In act 2, Maschler continues to try to be the "good Jew" but finally breaks, hopefully understanding what Stone got all along.

As to Dahl, he switches between being acerbic and conciliatory making one wonder if he is indeed antisemitic or if he's merely being provocative for the sake of being provocative - playing the role of cantankerous old man. That thought is put to rest at the close of the play as he's on the phone to a reporter who's giving him every opportunity to disavow his original comments only to see Dahl double down.

Of note was a comment made by Dahl, apparently a real quote that he was originally "only" an antizionist but became an antisemite.

This may sound familiar. It's the latest rage "I'm not antisemitic, just antizionist." Of course, Dahl's statement doesn't hold up to scrutiny any more than the current generation's claims as revealed at the close of the play when he talks of the lack of Jews participating in the war and with quotes like "there is a trait in the Jewish character that does provoke animosity. … Even a stinker like Hitler didn't just pick on them for no reason."

There's more to the play - does a mans personal beliefs, as twisted as they are devalue his work? What of Hallie, the domestic who's put in an uncomfortable position mid play almost having to either defend or condemn her employer. Was Dahl a child in an adult body - a childish mind giving birth to his worlds in literature but at the same time poisoning his views on reality?

I'm thankful that this play is currently on Broadway and has such an amazing cast. They don't sugarcoat Dahl's antisemitism and there's plenty in the play to expose antizionism for what it is, a cover for Jew hate.

You'll enjoy the performance and if you give it a chance, it'll leave you thinking.

See it if you can.

-1:-- Giant - Antisemitism, antizionism, and Roald Dahl (Post Mike Zamansky)--L0--C0--2026-05-31T15:41:10.000Z

Donovan R.: 💭 My Ancestors Were Writing Lisp

I’ve been hard on Lisp lately.

Last time I wrote here, I called it a curse — a language so powerful that everyone who touches it ends up building their own private dialect, until no one can quite understand anyone else. A small Tower of Babel, assembled out of parentheses. I still think that’s true.

But I left something out of that post, because it didn’t fit the argument I was making. The same Lisp idea that scatters programmers did the opposite thing to me, once. It didn’t scatter anything. It pulled something very old back together.

It gave me back my ancestors.


Let me explain, because it sounds like more than it is.

I’m not a Lisp programmer by trade. I just love the elegance of the thing — I’ve lived inside Emacs for years, written my own Elisp, poked at Clojure enough to feel what makes the family different. And the difference, the one everyone eventually trips over, is this: in Lisp, code and data are the same kind of thing. A list of symbols is information, or it’s a program, depending only on how you choose to read it. Data is code, and code is data.

Most people find that strange. Some find it beautiful. I was sitting with the strangeness of it one evening when something turned over in my head.

The vakana, I realized, were the same shape.

Vakana is our Malagasy word for beads — and there is no other word for them in my language, which tells you something about how old they are. I grew up knowing two things about them. That they were beautiful. And that they were a little frightening — in Madagascar, beads are tangled up with sorcery, and you learn young to keep a respectful distance.

What nobody told me — what I had to go the long way around to see — is that they were also a tool for thinking.

A bead has a form, a surface, a feeling it carries, a mark. Thread a few together and you have a sentence. Wear them in an order and you have a record. Pass them to someone and you have a message. The bead isn’t only worn — it’s read. And it doesn’t only get read; it does: it anchors a memory, marks an intention, names a person, declares a state. A unit that is at once what you say and what you mean. The exact shape a Lisp programmer knows in his fingers.

It was a small thing to notice, structurally. It was a very large thing for what it implied.

the vakana as a system

(Added after a reader asked for a concrete example.)


For most of my education I’d absorbed, without anyone ever saying it out loud, that the practices of my ancestors were aesthetic. Or spiritual. Or symbolic — and sometimes those words were just a polite way of saying not quite serious. The real thinking tools belonged to modernity: the journal, the calendar, the database.

But the vakana are exactly that. My ancestors used them the way I use a journal — to hold what happened, what to remember, what to commit to. The way I use a calendar — to pin meaning to a time and a place. The way an engineer uses a schema — to compose meaning out of a few fixed parts. They wore the whole system on the body, where it could be touched and counted without looking.

What I had been taught to see as ornament was the operating system.


There’s a second half to this, and it’s the half that turned the realization from clever into important.

Malagasy is a language made of pictures, and you hear it most clearly in the way we keep time. We don’t say one-thirty in the morning — we say mitrena ombilahy, the bellowing of the bull. Two in the morning is maneno sahona, when the frogs call. Six in the evening is maty masoandro, the death of the sun. (I wrote about this once: in Malagasy, time is told by what the world is doing, not by a number.) Even the turning of the year was read this way once. The month-names we use today are borrowed Arab zodiac, but the older Malagasy ones were small descriptions of the world — Papangolahy lava elatra, the long winged male Papango, for the season the zodiac calls Aries.

And it isn’t only time. The names themselves are descriptions. A tree can be called Mpanjakaben’ny tany, the great king of the earth; the pomegranate is Apongaben-danitra, heaven’s great drum. A person’s name can be a whole sentence — Andriantsimitoviaminandriandehibe: the noble without equal among the great nobles. To name a thing, in Malagasy, is already to draw it. To think in the language is to think in pictures.

I knew, before I made the connection, how much that matters — because I’d wandered into the Art of Memory. The Memory Palace: the old trick that lets a person hold a whole shuffled deck, or a thousand names, by placing vivid images in remembered rooms. It works because memory is built for image and place far more than for word and order. The Greeks thought they’d discovered it. They were late too.

The classical memory artists knew one more thing — that the kind of image matters. An image that frightens or shocks or moves you sticks; a neutral one slides off. And here is the part that stopped me: the vakana names are already charged that way. Tsileondoza — roughly, disaster cannot undo it — is a bead worn against ruin. The whole intention compressed into one frightening word, carried on the body.

So the fear that follows the beads in Malagasy life — the sorcery, the thing I was taught to keep away from — was never a superstition wrapped around a harmless object. It was the technology working. An emotionally inert bead is a worse memory tool than a charged one. My ancestors built their system out of images that stick, and one of the surest ways to make an image stick is to make it a little dangerous.

It was a cognitive technology. It was also magic. I’ve stopped thinking those two sentences argue with each other.

Not yet another technique. Something bigger. Something stronger. One of the most sophisticated tools for thought any culture has ever produced — and most of us who inherited it have forgotten that this is what it ever was.

Let me not overstate it, though. The art is not dead. The ombiasy — our sages and healers, the keepers of the old knowledge — still hold the vakana, and hold it far more deeply than I do; there are things in it I probably can’t yet fathom. What’s been lost is not the tradition itself but the everyday relation most of us had to it — the way it was once common knowledge and is now a specialist’s, kept by a few while the rest of us learned only to be a little afraid of it.

I’d like that to be known again, by the rest of us. That, honestly, is most of why I’m doing any of this.


Here is what is mine, and what is not.

I didn’t invent the vakana — they’re older than my whole line. I didn’t discover that they form a language, either. That reading came from inside the tradition itself, and it had been set down in serious, scientific study years before I had any interest in note-taking or productivity — before I had even started to learn computer science. It was never mine to claim. And the bead itself was never the genius — the genius was the grammar that could take any object, even a foreign one, and make it carry meaning.

So what’s mine is small, and I want to keep it small. Only this: I happened to be standing in an unlikely spot — Malagasy, in love with Lisp, curious about memory — from which you could see that the bead and the list and the remembered room are the same idea wearing different clothes. That’s the whole of it. I noticed a rhyme. And I’m holding it lightly, the way you should hold any reading that hasn’t yet been proven wrong.


The app came after all of this. Not before.

A few posts ago I told you I was building something, and that I’d write about the journey. This is me, finally writing about it — except I owe you an honest correction. The tool isn’t the one I set out to make.

What I wanted was modest. Last year we planted trees, and I started watching the seasons turn — the jacaranda in flower, the odd little weeds that appear in winter and vanish before you’ve learned their names. I wanted to keep a journal of the plants in my garden: how they grew, what they were called in Malagasy, how my people once used them. Nothing on my phone fit the shape of it, so I started building something that would.

And the moment I did, the vakana insight walked in and asked to be tried. I reached for the bead-grammar almost as an experiment — could it hold a plant, a season, a cycle of growth? It could. And not only that: it held nearly everything else I had ever wanted to write down. I came back holding my ancestors’ beads. The journey took a turn I didn’t choose, and I followed it.

It’s called Vakana.mg, and I want to say plainly what it is and isn’t. It is not the vakana. The system is older than any of us and will outlast the app by a long way. What I’ve built is a working surface for it — a way to practise the grammar every day, on the phone most of us actually live inside, without a string of beads in the pocket. It’s an imperfect translation, because anything digital trying to carry something physical is imperfect. My own memory taught me that years ago, against my preferences: for remembering, the physical always wins.

But even imperfect work bears its fruits. The app lets the practice be kept, and re-read, and handed to someone else. And it lets the vakana be met, for the first time, by people who’d otherwise never hear the word.

If I do this honestly, the app won’t be the destination. It’ll be a door. Some who walk through it will be happy with the digital version. Some will want a real bead in the hand. Some will go and study what the ancestors actually did and bring back more than I ever could. All of that is good, and none of it belongs to me.


Lisp and the vakana turn out to be the same shape — a tiny grammar that composes without end — separated only by centuries and by what they’re made of. And neither of them hands you meaning. Lisp gives you a handful of parentheses and lets you build whatever you want; the bead gives you a handful of forms and lets you mean whatever you need. You can no more read the meaning off a stranger’s beads than off a stranger’s code — and I built the app that way on purpose.

I’ve written here before that you have to seek your own understanding — that no one can do that part for you, however much you’d like them to. The vakana is the same conviction, made into a tool.

Because no one can hand you your meaning, either: not a guru, not even a true elder — and not me. Not because the keepers are frauds; they hold real depth, more than I ever will. But a meaning you were handed, and did not make yourself, won’t hold — and an image you choose is the only kind that does. What an elder can give you, what I can give you, is the grammar: small, and old, and ours, and far stronger than I was taught. The meaning, you write yourself.

I’m building it for the few people who, reading this, will feel a small click of recognition.

It isn’t out yet — vakana.mg just says coming soon, which is honest. If you’d like to know when it’s ready, you can leave your email there.

If that’s you — stick around. I’ll be writing about the journey.

-1:-- 💭 My Ancestors Were Writing Lisp (Post Donovan R.)--L0--C0--2026-05-31T00:00:00.000Z

tusharhero: May I recommend: lesser known org-modes

~373 words. ~1 minutes.

For this month's Emacs carnival topic, May I recommend…, I would like to recommend two cool org minor modes I discovered recently, in the order of me discovering them.

org-num-mode

This mode adds numbering to headings. Like this:

  * 1 heading
 ** 1.1 subheading
 *** 1.1.1 subsubheading
 ** 1.2 subheading
 * 2 heading

This is not added to the text directly, only visually. I believe it is done via overlays.

org-toggle-pretty-entities

This mode converts some TeX markup into the respective UTF-8 symbols, visually (as prettify-mode does). You can get a list of all available entities(symbols) using org-entities-help. BTW, it is also possible to define your own in org-entities-user.

So to give you an idea how of how it looks,

 1_1 a_b^q q_p p^q

Gets prettified into,

1 1 a b q q p p q

Some of you might be wondering, "Why would I use this when I have org-preview?". This is much simpler for when you just need to type a symbol.

Another potential question could be "Why wouldn't I just C-x 8 RET (insert UTF-8 character, for those who are not aware)?", you can't do a superscript q or subscript q, since those symbols don't exist! Which is why I chose q for my demo above.

Also this is way more convenient than C-x 8 RET, and that reminds me, there is a similar feature to this which actually inserts UTF-8 characters into your buffers, C-x RET C-\ TeX RET. Then you just type the TeX markup as you normally would, and it inserts the actual symbols, but this too has the same problems as with directly inserting symbols, some symbols are simply not available.

As a side note: I am sick of having a Unicode character for ☃ and ⛄ but not a superscript and/or subscript for half the letters! Why???

Thankfully, I can just use this mode and type all the q q q I want. Also, org automatically exports it correctly when exporting to HTML!

-1:-- May I recommend: lesser known org-modes (Post tusharhero)--L0--C0--2026-05-30T18:30:00.000Z

Irreal: Reading Gmail In Emacs On macOS

As most of you know, I don’t use Gmail or anything else from Google—except YouTube—if I can help it. They have, sadly, moved from “Don’t be evil” to “Do whatever you need to do to make us money”. For reasons that we here at the Irreal bunker have a hard time understanding, lots of people disagree and are all in on Gmail and many of the other Google offerings.

If you’re one of those Gmail users, are running on a Mac, and are an Emacs user, you may want to read your Gmail from within Emacs. The problem is that it’s difficult to configure Gmail authentication. Yi-Ping Pan has a solution. He uses the Password app instead of OAuth2 and says that you can get everything set up in about 20 minutes. Take a look at his post for the details. He provides everything you need to get things running.

Webframp notes in a comment that Pan’s solution might not work if you have Google’s advance protection enabled. I can’t comment on that because: not a Gmail user.

Well, actually, I suppose that technically I am a Gmail user because I do have a Gmail address. I can’t remember the last time I got any mail from it but irrational paranoia keeps me from deleting it. How, then, do I deal with Gmail? Simple. I forward it do my main email account so that it appears normally without having to do anything special. Like many of you, I have several email accounts and I do the same thing with all of them: I forward them to my main email account. Mu4e makes sure that my answers come from the appropriate email address.

If you’re using Gmail as a secondary account, forwarding it to your main account may make more sense than jumping through Google’s hoops. Regardless, if you want to retrieve Gmail directly, Pan’s post has a good solution.

-1:-- Reading Gmail In Emacs On macOS (Post Irreal)--L0--C0--2026-05-30T14:48:45.000Z

Bicycle for Your Mind: Links of Note 2026-05-30

Kitty!Kitty!

macosxguru at the gmail thingie.

Note: Thanks to Photo by Baku Kerimbekova: https://www.pexels.com/photo/cozy-fluffy-cat-sleeping-on-bed-linen-32157260/

-1:-- Links of Note 2026-05-30 (Post Bicycle for Your Mind)--L0--C0--2026-05-30T07:00:00.000Z

Irreal: Auto Revert Ignore

Just a quickie from Marcin Borkowski (mbork) today. Like many of us, mbork likes to turn on global-auto-revert so that any file open in Emacs that gets changed by an external process has the changes reflected in the Emacs buffer.

Sometimes, though, you don’t want that to happen. Mbork gives the example of viewing a PDF file while LaTeX is updating it. The question is: how to prevent auto revert from updating certain modes.

That turns out to be pretty easy. As usual, Emacs has us covered. The global-auto-revert-ignore-modes variable lists all the modes that should be ignored by auto revert. You can check mbork’s post for the details but it’s really quite simple: you list the modes that auto revert should ignore and that’s it.

This is, really, a niche concern but if you have it, mbork’s post tells you how to avoid it.

-1:-- Auto Revert Ignore (Post Irreal)--L0--C0--2026-05-29T14:16:05.000Z

Kemal: Brainiac v2.0 released

#emacs #brainiac #productivity #systems

Time has come to release a new version of Brainiac. The whole configuration file has been almost completly restructured, cleaned up and properly commented. So I will declare this to be version 2.0.

Following changes have been made:

  • READ.md has been extended to explain the installation and usage.
  • Readability improvements:
    • All colors decisions are now left to Modus themes, we only change typografy, e.g. underline the PROG tasks to encode work in progress.
    • Multiple Org elements were restyled, e.g. ellipsis, tags etc., to improve scanability in large documents.
    • Added the configuration for fixed and variable pitch fonts. You may set the font family to your liking.
    • Packages org-bullets, org-appear and diminish introduced.
    • Priority cookies are removed after the task is closed, to remove visual clutter.
    • When saving, the tags will be aligned automatically.
  • Added number of matches to isearch.
  • Repeaters are now visible in the agenda.
  • When jumping to items from the agenda, automatic narrow is done to improve focus.
  • Capture from anywhere is now implemented by a custom script based on org-protocol.
  • Many, many small tweaks, fixes and changes.

Get the new release from here.

Enjoy and keep hacking!

-1:-- Brainiac v2.0 released (Post Kemal)--L0--C0--2026-05-29T11:54:23.000Z

Raymond Zeitler: Emacs -- It's Worth Revealing Oneself For

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

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 file2 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."3

Thank you, again, Sacha!


1Sacha Chua, https://sachachua.com/blog/#ID-ec23-transcript
2https://www.emacswiki.org/emacs/RaymondZeitler
3Sacha Chua, ibid.
-1:-- Emacs -- It's Worth Revealing Oneself For (Post Raymond Zeitler)--L0--C0--2026-05-28T17:07:20.129Z

Charles Choi: Anju v1.5.0 Update

Heads up for readers of this blog who are using Anju or are mouse-curious Emacs users. I’ve recently released the v1.5.0 update for it, now available on MELPA.

Many new features and enhancements are in this update as outlined below:

Users who work with both Org mode and Markdown formatted text should find interest in the Copy as… capability added to the Org mode context menu. This feature lets one use Org mode as the primary means of authoring text, exporting to Markdown (or another format) using a right-click mouse copy action.

img

Thanks to Marcin Borkowski whose post “Org-mode to Markdown via the clipboard”, inspired this feature.

Anju also provides a complementary command “Paste Markdown as Org” for Org mode which lets one paste copied Markdown text into an Org file, doing the conversion of Markdown to Org under the hood using pandoc.

img

In summary, this is a big release with many changes. I invite you to explore all the links above to see what’s available in Anju.

-1:-- Anju v1.5.0 Update (Post Charles Choi)--L0--C0--2026-05-28T17:00:00.000Z

Raymond Zeitler: zap-to-char M-z

Sometimes I discover an Emacs feature after an accidental keystroke. If I can remember the keystroke, I'll invoke the keystroke help (C-h k) to learn about it. Or sometimes the prompt in the mode line will suggest the function's name.

Today, the keystroke was M-z , which is bound to the function zap-to-char.

It seems to be ideal if, like me, you doze briefly while typing a senteeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

Oops, there I go again!

To fix that I can just press M-- M-z t to delete all the trailing "e" characters.

Note that M-- is invoked by holding down the Alt key while pressing hyphen. It defines a negative prefix argument, which instructs zap-to-char to "go backward," deleting all characters from point to the specified character ("t"). I'm not sure how or why you'd want the default "forward" behavior.

What accidental keystroke have you discovered recently?

-1:-- zap-to-char M-z (Post Raymond Zeitler)--L0--C0--2026-05-28T16:30:37.052Z

Raymond Zeitler: Emacs view- Commands

A kind reader suggested I try the view-lossage command to display a list of recent keystrokes. This would be helpful for those times when I press a key accidentally and don't know what I did (as described in "zap-to-char M-z").

The output resembles what you'd get from edit-kbd-macro (assuming that a keyboard macro had been defined). This provides an alternate way to define a keyboard macro -- just select the desired portion of the output and invoke read-kbd-macro.  At this point you can "play back" those keystrokes with C-x e.

After I understood view-lossage,  I skimmed through the list of commands that start with view- (by doing M-x view- TAB). The commands view-buffer,  view-file(and variants that view in another buffer, window, frame) provide a safe (read-only) way to examine the contents of a buffer or file.

Entering M-x view-file-other-frame .emacs allows me to display my init file in a new Emacs frame and close it (by pressing "q") when I'm done with it. And then I don't have to worry about changing it inadvertently.

-1:-- Emacs view- Commands (Post Raymond Zeitler)--L0--C0--2026-05-28T16:14:29.129Z

Irreal: Zap-to-char Backwards

Today was a good Emacs day. I learned something new. Over at Ray on Emacs, Raymond Zeitler has a very nice post on using zap-to-char in reverse. He—hypothetically—was typing some text, inadvertently leaned on a key, and ended up with a long string of a repeated character at the end of his text. Something like this:

senteeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

Here’s what I didn’t know. You can cause zap-to-char to delete characters to the left by giving it negative count argument. So in Zeitler’s example, he erases the string of e​s by calling zap-to-char as Meta+- Meta+z t.

But that’s not quite right. The problem is that it will also erase the t, which I assume was not his intention. Fortunately, there’s an easy solution that I wrote about almost 14 years ago. The problem with zap-to-char is that it does what you want it to only about half the time. The rest of the time you don’t want to delete the target character; you want to delete up to but not including that character. It turns out that Emacs has a command, zap-up-to-char, to do that but it’s not bound to any shortcut1. I have it bound to Meta+Z. It also honors the negative count argument so the correct solution for Zeitler’s problem is Meta+- Meta+Z t.

The mistake aside, this is a great post because it tells me—and maybe you—something I didn’t know: you can zap backwards.

Footnotes:

1

Happily, it’s now autoloaded by default so you no longer have to worry about that.

-1:-- Zap-to-char Backwards (Post Irreal)--L0--C0--2026-05-28T14:47:00.000Z

James Dyer: Stashing a Single File, and Why I Was Too Quick to Blame vc-mode!

In my last post I wrote about finally caving in and adding Magit to my config after years of being a contented vc-mode loyalist (VC-Mode Meets Magit - or Why I Finally Gave In!). My conclusion then was that the two complement each other nicely, Magit for repo-level operations, vc-mode for the everyday file-level stuff, commit a single file, a blame, a quick diff, C-x v and away you go. Well, I have just had a small but instructive lesson in not assuming where the limitations actually lie, because I caught myself about to reach for Magit for something vc-mode handles perfectly well!

20260528103245-emacs--Stashing-a-Single-File-and-Why-I-Was-Too-Quick-to-Blame-vc-mode.jpg

The scenario: I had a pile of changes sitting in my working tree across a few files, and I wanted to set aside the changes in just one of them, temporarily, without touching anything else. Stash a single file, in other words.

I knew that vc-mode had some stash commands through the "z" keybinding when in vc-dir, and of course you can find them through M-x by completing on vc-git-stash*, but I had only ever used it for stashing everything, straight from the worktree. So I did a quick test: in vc-mode, I moved my point over a single modified file and selected vc-git-stash, but this of course would stash everything! Well, how about a single file? I assumed that vc-mode couldn't do it and reached for magit instead!

However a little niggling doubt surfaced and I decided to have a little rummage around the vc-git code:

(defun vc-git-stash (name)
  "Create a stash given the name NAME."
  (interactive "sStash name: ")
  (let ((root (vc-git-root default-directory)))
    (when root
      (apply #'vc-git--call nil "stash" "push" "-m" name
             (when (derived-mode-p 'vc-dir-mode)
               (vc-dir-marked-files)))
      (vc-resynch-buffer root t t))))

It runs git stash push -m NAME and, if you are inside a vc-dir buffer, it appends the list of marked files as a pathspec. Which means a single-file stash is built right in, no Magit required!

  1. Open vc-dir with C-x v d (or C-x p v for the project-wide view)
  2. Move point to the file you want to set aside and press m to mark it
  3. Press z c, type a stash name, hit return

And that is it, git stash push -m "your name" -- the/marked/file runs under the hood, that one file's changes are tucked away, and everything else in your working tree is left exactly as it was. Mark two files and it stashes two, mark none and it stashes the lot, the marking is the whole mechanism.

To bring it back, z p pops a stash (it prompts you with a completing-read list of what is there)

This is almost the inverse of my last git post. Last time I went looking for vc-rebase and there genuinely was not one, a real git-specific gap that vc-mode does not fill, and off to Magit I rightly went. This time I assumed the same shape of limitation and assumed wrong, the feature was sitting there in vc-dir the whole time (and actually was pretty obvious really),

So, vc-mode really is quite capable for file-level git work, single-file stashing very much included, and I should be slower to assume "git-specific" means "Magit only". Magit is still there for the repo-level heavy lifting, but for tucking one file out of the way, C-x v d, m, z c, done, no need to leave the comfort of the built-in tooling at all.

I do enjoy these little corrections, each one teaches me a bit more about where the seams in Emacs version control actually are, and occasionally, that the seam I thought I had found was never there in the first place!

-1:-- Stashing a Single File, and Why I Was Too Quick to Blame vc-mode! (Post James Dyer)--L0--C0--2026-05-28T09:32:00.000Z

Andros Fenollosa: Playing chess online with Emacs

Every now and then I like to play a game of chess with my colleagues at the office, without ever leaving my favourite Elisp interpreter. Emacs has a really good package for this, chess, which supports several ways to play: against the machine, over a local network, against internet chess servers (ICS), and even through IRC (I am proud to say I finished implementing that last feature myself). You can check out the official documentation.

Chess board in Emacs

So I would like to share a brief introduction to playing chess over a network from Emacs.

Local network game

Lets you play directly between two Emacs sessions over TCP. You can use it to play with a friend on the same local network or VPN.

Launch it with:

C-u M-x chess RET network RET

On startup it asks which role you want:

  • Server: opens a local port and waits for a connection. Uses open-network-stream-server (or nc -l -p as a fallback if not available).
  • Client: prompts for a host and port, then connects.

Internet chess servers (ICS)

Maybe you have a favourite online chess provider, or you want to test your skills against players from around the world.

Launch it directly with:

M-x chess-ics

Connects to real ICS servers. The preconfigured ones are:

Server Port
freechess.org 5000
chessclub.com 5000
chess.net 5000
chess.unix-ag.uni-kl.de 5000
oics.olympuschess.com 5000

Supports login with a handle and password.

Playing through IRC

To play over IRC, run:

M-x chess-irc

It will connect to your configured IRC server, then ask for your opponent's nick. Your opponent needs to do the same on their end. No worries about privacy: the game uses private messages.

Note: this feature is part of my Pull Request, so if you do not see it, you may need to update your chess version or build it from the repository.

Extensions for modern platforms

There are other platforms you can play on using external packages:

Final notes

My configuration:

(use-package chess
  :ensure t
  :config
  (setq chess-images-separate-frame nil) ; Display the board in the same frame
  (setq chess-images-default-size 100))  ; Piece size in pixels

One last piece of advice: play against humans. The AI is quite easy, and while winning is fun, it is not much of a challenge. You will also get to meet more people that way. Checkmate!

I hope you enjoy your chess games inside Emacs as much as I do.

-1:-- Playing chess online with Emacs (Post Andros Fenollosa)--L0--C0--2026-05-28T07:28:52.000Z

Please note that planet.emacslife.com aggregates blogs, and blog authors might mention or link to nonfree things. To add a feed to this page, please e-mail the RSS or ATOM feed URL to sacha@sachachua.com . Thank you!